@pontalabs/baileys 1.0.10 → 1.1.0

package/lib/Utils/signal.js

@@ -1,166 +1,183 @@
-"use strict"
-
-Object.defineProperty(exports, "__esModule", { value: true })
-
-const lodash_1 = require("lodash")
-const Defaults_1 = require("../Defaults")
-const WABinary_1 = require("../WABinary")
-const crypto_1 = require("./crypto")
-const generics_1 = require("./generics")
-
-const createSignalIdentity = (wid, accountSignatureKey) => {
-    return {
-        identifier: { name: wid, deviceId: 0 },
-        identifierKey: crypto_1.generateSignalPubKey(accountSignatureKey)
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { KEY_BUNDLE_TYPE: KEY_BUNDLE_TYPE } = require("../Defaults/constants");
+const {
+    S_WHATSAPP_NET: S_WHATSAPP_NET,
+    getBinaryNodeChild: getBinaryNodeChild,
+    getBinaryNodeChildren: getBinaryNodeChildren,
+    getBinaryNodeChildUInt: getBinaryNodeChildUInt,
+    getBinaryNodeChildBuffer: getBinaryNodeChildBuffer,
+    assertNodeErrorFree: assertNodeErrorFree,
+    jidDecode: jidDecode,
+    getServerFromDomainType: getServerFromDomainType,
+    WAJIDDomains: WAJIDDomains,
+} = require("../WABinary");
+const { Curve: Curve, generateSignalPubKey: generateSignalPubKey } = require("./crypto");
+const { encodeBigEndian: encodeBigEndian } = require("./generics");
+function chunk(array, size) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += size) {
+        chunks.push(array.slice(i, i + size));
     }
+    return chunks;
 }
-
-const getPreKeys = async ({ get }, min, limit) => {
-    const idList = []
+const createSignalIdentity = (wid, accountSignatureKey) => ({
+    identifier: { name: wid, deviceId: 0 },
+    identifierKey: generateSignalPubKey(accountSignatureKey),
+});
+const getPreKeys = async ({ get: get }, min, limit) => {
+    const idList = [];
     for (let id = min; id < limit; id++) {
-        idList.push(id.toString())
+        idList.push(id.toString());
     }
-    return get('pre-key', idList)
-}
-
+    return get("pre-key", idList);
+};
 const generateOrGetPreKeys = (creds, range) => {
-    const avaliable = creds.nextPreKeyId - creds.firstUnuploadedPreKeyId
-    const remaining = range - avaliable
-    const lastPreKeyId = creds.nextPreKeyId + remaining - 1
-    const newPreKeys = {}
+    const avaliable = creds.nextPreKeyId - creds.firstUnuploadedPreKeyId;
+    const remaining = range - avaliable;
+    const lastPreKeyId = creds.nextPreKeyId + remaining - 1;
+    const newPreKeys = {};
     if (remaining > 0) {
         for (let i = creds.nextPreKeyId; i <= lastPreKeyId; i++) {
-            newPreKeys[i] = crypto_1.Curve.generateKeyPair()
+            newPreKeys[i] = Curve.generateKeyPair();
         }
     }
     return {
-        newPreKeys,
-        lastPreKeyId,
+        newPreKeys: newPreKeys,
+        lastPreKeyId: lastPreKeyId,
         preKeysRange: [creds.firstUnuploadedPreKeyId, range],
-    }
-}
-
+    };
+};
 const xmppSignedPreKey = (key) => ({
-    tag: 'skey',
+    tag: "skey",
     attrs: {},
     content: [
-        { tag: 'id', attrs: {}, content: generics_1.encodeBigEndian(key.keyId, 3) },
-        { tag: 'value', attrs: {}, content: key.keyPair.public },
-        { tag: 'signature', attrs: {}, content: key.signature }
-    ]
-})
-
+        { tag: "id", attrs: {}, content: encodeBigEndian(key.keyId, 3) },
+        { tag: "value", attrs: {}, content: key.keyPair.public },
+        { tag: "signature", attrs: {}, content: key.signature },
+    ],
+});
 const xmppPreKey = (pair, id) => ({
-    tag: 'key',
+    tag: "key",
     attrs: {},
     content: [
-        { tag: 'id', attrs: {}, content: generics_1.encodeBigEndian(id, 3) },
-        { tag: 'value', attrs: {}, content: pair.public }
-    ]
-})
-
+        { tag: "id", attrs: {}, content: encodeBigEndian(id, 3) },
+        { tag: "value", attrs: {}, content: pair.public },
+    ],
+});
 const parseAndInjectE2ESessions = async (node, repository) => {
-    const extractKey = (key) => (key ? ({
-        keyId: WABinary_1.getBinaryNodeChildUInt(key, 'id', 3),
-        publicKey: crypto_1.generateSignalPubKey(WABinary_1.getBinaryNodeChildBuffer(key, 'value')),
-        signature: WABinary_1.getBinaryNodeChildBuffer(key, 'signature')
-    }) : undefined)
-    const nodes = WABinary_1.getBinaryNodeChildren(WABinary_1.getBinaryNodeChild(node, 'list'), 'user')
+    const extractKey = (key) =>
+        key
+            ? {
+                  keyId: getBinaryNodeChildUInt(key, "id", 3),
+                  publicKey: generateSignalPubKey(getBinaryNodeChildBuffer(key, "value")),
+                  signature: getBinaryNodeChildBuffer(key, "signature"),
+              }
+            : undefined;
+    const nodes = getBinaryNodeChildren(getBinaryNodeChild(node, "list"), "user");
     for (const node of nodes) {
-        WABinary_1.assertNodeErrorFree(node)
+        assertNodeErrorFree(node);
     }
-    // Most of the work in repository.injectE2ESession is CPU intensive, not IO
-    // So Promise.all doesn't really help here,
-    // but blocks even loop if we're using it inside keys.transaction, and it makes it "sync" actually
-    // This way we chunk it in smaller parts and between those parts we can yield to the event loop
-    // It's rare case when you need to E2E sessions for so many users, but it's possible
-    const chunkSize = 100
-    const chunks = lodash_1.chunk(nodes, chunkSize)
+    const chunkSize = 100;
+    const chunks = chunk(nodes, chunkSize);
     for (const nodesChunk of chunks) {
-        await Promise.all(nodesChunk.map(async (node) => {
-            const signedKey = WABinary_1.getBinaryNodeChild(node, 'skey')
-            const key = WABinary_1.getBinaryNodeChild(node, 'key')
-            const identity = WABinary_1.getBinaryNodeChildBuffer(node, 'identity')
-            const jid = node.attrs.jid
-            const registrationId = WABinary_1.getBinaryNodeChildUInt(node, 'registration', 4)
+        for (const node of nodesChunk) {
+            const signedKey = getBinaryNodeChild(node, "skey");
+            const key = getBinaryNodeChild(node, "key");
+            const identity = getBinaryNodeChildBuffer(node, "identity");
+            const jid = node.attrs.jid;
+            const registrationId = getBinaryNodeChildUInt(node, "registration", 4);
             await repository.injectE2ESession({
-                jid,
+                jid: jid,
                 session: {
                     registrationId: registrationId,
-                    identityKey: crypto_1.generateSignalPubKey(identity),
+                    identityKey: generateSignalPubKey(identity),
                     signedPreKey: extractKey(signedKey),
-                    preKey: extractKey(key)
-                }
-            })
-        }))
+                    preKey: extractKey(key),
+                },
+            });
+        }
     }
-}
-
-const extractDeviceJids = (result, myJid, excludeZeroDevices) => {
-    const { user: myUser, device: myDevice } = WABinary_1.jidDecode(myJid)
-    const extracted = []
+};
+const extractDeviceJids = (result, myJid, myLid, excludeZeroDevices) => {
+    const { user: myUser, device: myDevice } = jidDecode(myJid);
+    const extracted = [];
     for (const userResult of result) {
-        const { devices, id } = userResult
-        const { user } = WABinary_1.jidDecode(id)
-        const deviceList = devices?.deviceList
-        if (Array.isArray(deviceList)) {
-            for (const { id: device, keyIndex } of deviceList) {
-                if ((!excludeZeroDevices || device !== 0) && // if zero devices are not-excluded, or device is non zero
-                    (myUser !== user || myDevice !== device) && // either different user or if me user, not this device
-                    (device === 0 || !!keyIndex) // ensure that "key-index" is specified for "non-zero" devices, produces a bad req otherwise
-                ) {
-                    extracted.push({ user, device })
+        const { devices: devices, id: id } = userResult;
+        const decoded = jidDecode(id),
+            { user: user, server: server } = decoded;
+        let { domainType: domainType } = decoded;
+        const deviceList = devices?.deviceList;
+        if (!Array.isArray(deviceList)) continue;
+        for (const { id: device, keyIndex: keyIndex, isHosted: isHosted } of deviceList) {
+            if (
+                (!excludeZeroDevices || device !== 0) &&
+                ((myUser !== user && myLid !== user) || myDevice !== device) &&
+                (device === 0 || !!keyIndex)
+            ) {
+                if (isHosted) {
+                    domainType =
+                        domainType === WAJIDDomains.LID
+                            ? WAJIDDomains.HOSTED_LID
+                            : WAJIDDomains.HOSTED;
                 }
+                extracted.push({
+                    user: user,
+                    device: device,
+                    domainType: domainType,
+                    server: getServerFromDomainType(server, domainType),
+                });
             }
         }
     }
-    return extracted
-}
-
-/**
- * get the next N keys for upload or processing
- * @param count number of pre-keys to get or generate
- */
-const getNextPreKeys = async ({ creds, keys }, count) => {
-    const { newPreKeys, lastPreKeyId, preKeysRange } = generateOrGetPreKeys(creds, count)
+    return extracted;
+};
+const getNextPreKeys = async ({ creds: creds, keys: keys }, count) => {
+    const {
+        newPreKeys: newPreKeys,
+        lastPreKeyId: lastPreKeyId,
+        preKeysRange: preKeysRange,
+    } = generateOrGetPreKeys(creds, count);
     const update = {
         nextPreKeyId: Math.max(lastPreKeyId + 1, creds.nextPreKeyId),
-        firstUnuploadedPreKeyId: Math.max(creds.firstUnuploadedPreKeyId, lastPreKeyId + 1)
-    }
-    await keys.set({ 'pre-key': newPreKeys })
-    const preKeys = await getPreKeys(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1])
-    return { update, preKeys }
-}
-
+        firstUnuploadedPreKeyId: Math.max(creds.firstUnuploadedPreKeyId, lastPreKeyId + 1),
+    };
+    await keys.set({ "pre-key": newPreKeys });
+    const preKeys = await getPreKeys(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1]);
+    return { update: update, preKeys: preKeys };
+};
 const getNextPreKeysNode = async (state, count) => {
-    const { creds } = state
-    const { update, preKeys } = await getNextPreKeys(state, count)
+    const { creds: creds } = state;
+    const { update: update, preKeys: preKeys } = await getNextPreKeys(state, count);
     const node = {
-        tag: 'iq',
-        attrs: {
-            xmlns: 'encrypt',
-            type: 'set',
-            to: WABinary_1.S_WHATSAPP_NET,
-        },
+        tag: "iq",
+        attrs: { xmlns: "encrypt", type: "set", to: S_WHATSAPP_NET },
         content: [
-            { tag: 'registration', attrs: {}, content: generics_1.encodeBigEndian(creds.registrationId) },
-            { tag: 'type', attrs: {}, content: Defaults_1.KEY_BUNDLE_TYPE },
-            { tag: 'identity', attrs: {}, content: creds.signedIdentityKey.public },
-            { tag: 'list', attrs: {}, content: Object.keys(preKeys).map(k => xmppPreKey(preKeys[+k], +k)) },
-            xmppSignedPreKey(creds.signedPreKey)
-        ]
-    }
-    return { update, node }
-}
-
+            {
+                tag: "registration",
+                attrs: {},
+                content: encodeBigEndian(creds.registrationId),
+            },
+            { tag: "type", attrs: {}, content: KEY_BUNDLE_TYPE },
+            { tag: "identity", attrs: {}, content: creds.signedIdentityKey.public },
+            {
+                tag: "list",
+                attrs: {},
+                content: Object.keys(preKeys).map((k) => xmppPreKey(preKeys[+k], +k)),
+            },
+            xmppSignedPreKey(creds.signedPreKey),
+        ],
+    };
+    return { update: update, node: node };
+};
 module.exports = {
-  createSignalIdentity, 
-  getPreKeys, 
-  generateOrGetPreKeys, 
-  xmppSignedPreKey, 
-  xmppPreKey, 
-  parseAndInjectE2ESessions, 
-  extractDeviceJids, 
-  getNextPreKeys, 
-  getNextPreKeysNode
-}
+    createSignalIdentity: createSignalIdentity,
+    getPreKeys: getPreKeys,
+    generateOrGetPreKeys: generateOrGetPreKeys,
+    xmppSignedPreKey: xmppSignedPreKey,
+    xmppPreKey: xmppPreKey,
+    parseAndInjectE2ESessions: parseAndInjectE2ESessions,
+    extractDeviceJids: extractDeviceJids,
+    getNextPreKeys: getNextPreKeys,
+    getNextPreKeysNode: getNextPreKeysNode,
+};

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

@@ -1,171 +1,104 @@
-"use strict"
-
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod }
-}
-
-Object.defineProperty(exports, "__esModule", { value: true })
-
-const async_mutex_1 = __importDefault(require("async-mutex"))
-const promises_1 = require("fs/promises")
-const { rename: fsRename } = promises_1
-const path_1 = require("path")
-const WAProto_1 = require("../../WAProto")
-const auth_utils_1 = require("./auth-utils")
-const generics_1 = require("./generics")
-// We need to lock files due to the fact that we are using async functions to read and write files
-// https://github.com/WhiskeySockets/Baileys/issues/794
-// https://github.com/nodejs/node/issues/26338
-// Use a Map to store mutexes for each file path
-const fileLocks = new Map()
-
-// Get or create a mutex for a specific file path
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { Mutex: Mutex } = require("async-mutex");
+const { promises: promises } = require("fs");
+const { join: join } = require("path");
+const { proto: proto } = require("../../WAProto");
+const { initAuthCreds: initAuthCreds } = require("./auth-utils");
+const { BufferJSON: BufferJSON } = 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
-}
-
-// Lepas mutex dari Map begitu tidak dipakai lagi supaya tidak numpuk terus (memory leak)
-// selama proses hidup lama (bot jalan berbulan-bulan dengan ribuan file sesi berbeda).
-const releaseFileLock = (path) => {
-	fileLocks.delete(path)
-}
-
-/**
- * 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
- * */
+    let mutex = fileLocks.get(path);
+    if (!mutex) {
+        mutex = new Mutex();
+        fileLocks.set(path, mutex);
+    }
+    return mutex;
+};
 const useMultiFileAuthState = async (folder) => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const writeData = async (data, file) => {
-        const filePath = path_1.join(folder, fixFileName(file))
-        const mutex = getFileLock(filePath)
+        const filePath = join(folder, fixFileName(file));
+        const mutex = getFileLock(filePath);
         return mutex.acquire().then(async (release) => {
             try {
-                // Atomic write: write to temp file then rename, agar file tidak pernah
-                // kebaca dalam kondisi setengah tertulis kalau proses mati di tengah jalan.
-                const tmpPath = filePath + '.tmp'
-                await promises_1.writeFile(tmpPath, JSON.stringify(data, generics_1.BufferJSON.replacer))
-                await fsRename(tmpPath, filePath)
+                await promises.writeFile(filePath, JSON.stringify(data, BufferJSON.replacer));
             } finally {
-                release()
-                releaseFileLock(filePath)
+                release();
             }
-        })
-    }
+        });
+    };
     const readData = async (file) => {
-        const filePath = path_1.join(folder, fixFileName(file))
         try {
-            const mutex = getFileLock(filePath)
+            const filePath = join(folder, fixFileName(file));
+            const mutex = getFileLock(filePath);
             const data = await mutex.acquire().then(async (release) => {
                 try {
-                    return await promises_1.readFile(filePath, { encoding: 'utf-8' })
+                    return await promises.readFile(filePath, { encoding: "utf-8" });
                 } finally {
-                    release()
-                    releaseFileLock(filePath)
+                    release();
                 }
-            })
-
-            return JSON.parse(data, generics_1.BufferJSON.reviver)
+            });
+            return JSON.parse(data, BufferJSON.reviver);
         } catch (error) {
-            // ENOENT (file belum ada) itu normal, tapi kalau isinya rusak/corrupt (JSON parse
-            // gagal) itu wajib kelihatan di log, bukan diam-diam dianggap "null"/hilang.
-            if (error?.code !== 'ENOENT') {
-                console.warn(`[useMultiFileAuthState] Gagal membaca/parse ${filePath}:`, error?.message || error)
-            }
-            return null
+            return null;
         }
-    }
+    };
     const removeData = async (file) => {
-        const filePath = path_1.join(folder, fixFileName(file))
         try {
-            const mutex = getFileLock(filePath)
+            const filePath = join(folder, fixFileName(file));
+            const mutex = getFileLock(filePath);
             await mutex.acquire().then(async (release) => {
-               try {
-                    await promises_1.unlink(filePath)
+                try {
+                    await promises.unlink(filePath);
                 } finally {
-                    release()
-                    releaseFileLock(filePath)
+                    release();
                 }
-            })
+            });
         } catch {}
-    }
-    const folderInfo = await promises_1.stat(folder).catch(() => { })
+    };
+    const folderInfo = await promises.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`)
+            throw new Error(
+                `found something that is not a directory at ${folder}, either delete it or specify a different location`
+            );
         }
+    } else {
+        await promises.mkdir(folder, { recursive: true });
     }
-    else {
-        await promises_1.mkdir(folder, { recursive: true })
-    }
-    const fixFileName = (file) => {
-        return file?.replace(/\//g, '__')?.replace(/:/g, '-')
-    }
-
-    // Bersihkan file .tmp "yatim" yang tertinggal dari proses sebelumnya yang mati
-    // di tengah proses rename (atomic write). File-file ini tidak berguna dan kalau
-    // dibiarkan menumpuk, cuma buang-buang disk.
-    try {
-        const entries = await promises_1.readdir(folder)
-        await Promise.all(
-            entries
-                .filter((name) => name.endsWith('.tmp'))
-                .map((name) => promises_1.unlink(path_1.join(folder, name)).catch(() => {}))
-        )
-    } catch {}
-
-    const creds = await readData('creds.json') || auth_utils_1.initAuthCreds()
+    const fixFileName = (file) => file?.replace(/\//g, "__")?.replace(/:/g, "-");
+    const creds = (await readData("creds.json")) || initAuthCreds();
     return {
         state: {
-            creds,
+            creds: 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 = WAProto_1.proto.Message.AppStateSyncKeyData.fromObject(value)
-                        }
-                        data[id] = value
-                    }))
-                    return data
+                    const data = {};
+                    await Promise.all(
+                        ids.map(async (id) => {
+                            let value = await readData(`${type}-${id}.json`);
+                            if (type === "app-state-sync-key" && value) {
+                                value = proto.Message.AppStateSyncKeyData.fromObject(value);
+                            }
+                            data[id] = value;
+                        })
+                    );
+                    return data;
                 },
                 set: async (data) => {
-                    const tasks = []
+                    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))
+                            const value = data[category][id];
+                            const file = `${category}-${id}.json`;
+                            tasks.push(value ? writeData(value, file) : removeData(file));
                         }
                     }
-                    await Promise.all(tasks)
-                }
-            }
-        },
-        // saveCreds sekarang selalu langsung menulis (tidak didebounce). creds.json adalah
-        // file paling kritis — kalau proses mati tepat di jendela debounce, sesi bisa hilang
-        // atau balik ke state lama sehingga semua pesan gagal didekripsi setelah reconnect.
-        saveCreds: async () => {
-            return writeData(creds, 'creds.json')
+                    await Promise.all(tasks);
+                },
+            },
         },
-        // Tetap disediakan sebagai alias untuk kompatibilitas kode lama yang memanggil
-        // saveCredsNow() secara eksplisit (misal di handler disconnect/cleanup).
-        saveCredsNow: async () => {
-            return writeData(creds, 'creds.json')
-        }
-    }
-}
-
-module.exports = {
-  useMultiFileAuthState
-}
+        saveCreds: async () => writeData(creds, "creds.json"),
+    };
+};
+module.exports = { useMultiFileAuthState: useMultiFileAuthState };