rixleys 1.0.0

package/lib/Utils/serializer.js

@@ -0,0 +1,238 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serialize = serialize;
+exports.smsg = serialize;
+exports.getContentType = getContentType;
+exports.getDevice = getDevice;
+exports.extractText = extractText;
+
+const jid_utils_1 = require("../WABinary/jid-utils");
+
+/**
+ * Buffer stream helper
+ */
+const toBuffer = async (stream) => {
+    let buffer = Buffer.from([]);
+    for await (const chunk of stream) buffer = Buffer.concat([buffer, chunk]);
+    return buffer;
+};
+
+/**
+ * Extract plain text / caption from message object
+ */
+function extractText(msg = {}, type = "") {
+    return (
+        msg?.conversation ||
+        msg?.[type]?.text ||
+        msg?.[type]?.caption ||
+        msg?.[type]?.contentText ||
+        msg?.[type]?.selectedDisplayText ||
+        ""
+    );
+}
+
+/**
+ * Get content type of message
+ */
+function getContentType(content) {
+    if (content) {
+        const keys = Object.keys(content);
+        const key = keys.find(
+            (k) =>
+                (k === "conversation" || k.endsWith("Message") || k.includes("V2")) &&
+                k !== "senderKeyDistributionMessage"
+        );
+        return key;
+    }
+}
+
+/**
+ * Device detector from Stanza ID
+ */
+function getDevice(id) {
+    if (!id) return "UNKNOWN";
+    if (id.length > 21) return "ANDROID";
+    if (id.substring(0, 2) === "3A") return "IOS";
+    if (id.substring(0, 4) === "3EB0") return "WEB";
+    if (id.startsWith("BAE5") || id.startsWith("3EB0") || id.startsWith("B1E") || id.startsWith("3F8")) return "BOT";
+    return "UNKNOWN";
+}
+
+/**
+ * Serialize WhatsApp Message
+ * @param {any} sock Baileys / Rixleys socket instance (optional)
+ * @param {any} m Raw message payload from messages.upsert
+ * @returns {any} Serialized message
+ */
+function serialize(sock, m) {
+    if (!m) {
+        m = sock;
+        sock = null;
+    }
+    if (!m) return null;
+
+    const msg = m.messages?.[0] || m;
+    if (!msg?.message) return m;
+
+    // Chat JID & Group Flag
+    m.chat = msg.key?.remoteJid || "";
+    m.isGroup = (0, jid_utils_1.isJidGroup)(m.chat) || m.chat.endsWith("@g.us");
+    m.fromMe = !!msg.key?.fromMe;
+    m.id = msg.key?.id || "";
+    m.pushName = msg.pushName || "";
+    m.device = getDevice(m.id);
+
+    // ==========================================
+    // SENDER RESOLVER (m.senderJid & m.senderLid)
+    // ==========================================
+    const rawParticipant =
+        msg.key?.participantAlt ||
+        msg.key?.participantPn ||
+        msg.key?.participant ||
+        msg.key?.remoteJidAlt ||
+        msg.key?.remoteJid ||
+        "";
+
+    const normalizedSender = (0, jid_utils_1.jidNormalizedUser)(rawParticipant);
+
+    if (normalizedSender.endsWith("@lid")) {
+        m.senderLid = normalizedSender;
+        const altPn = msg.key?.participantPn || msg.key?.participantAlt;
+        m.senderJid = altPn ? (0, jid_utils_1.jidNormalizedUser)(altPn) : normalizedSender;
+    } else {
+        m.senderJid = normalizedSender;
+        const altLid = msg.key?.participantAlt?.endsWith("@lid")
+            ? (0, jid_utils_1.jidNormalizedUser)(msg.key.participantAlt)
+            : null;
+        m.senderLid = altLid || null;
+    }
+
+    m.sender = m.senderJid;
+    m.Pn = m.senderJid ? m.senderJid.replace(/[^0-9]/g, "") : "";
+
+    // Content Type & Body
+    m.mtype = getContentType(msg.message) || "";
+    m.text = extractText(msg.message, m.mtype);
+    m.body = m.text;
+
+    // Context Info & Quoted
+    const ctx =
+        msg.message?.extendedTextMessage?.contextInfo ||
+        msg.message?.[m.mtype]?.contextInfo ||
+        null;
+
+    m.mentionedJid = ctx?.mentionedJid || [];
+    m.quoted = null;
+
+    // ==========================================
+    // QUOTED MESSAGE WRAPPER (m.quoted)
+    // ==========================================
+    if (ctx?.quotedMessage) {
+        const qMsg = ctx.quotedMessage;
+        const qType = getContentType(qMsg) || "";
+        const qInner = qMsg?.[qType] || {};
+
+        const qRawParticipant = ctx.participant || "";
+        const qNormalizedSender = (0, jid_utils_1.jidNormalizedUser)(qRawParticipant);
+
+        let qSenderJid = qNormalizedSender;
+        let qSenderLid = null;
+
+        if (qNormalizedSender.endsWith("@lid")) {
+            qSenderLid = qNormalizedSender;
+            qSenderJid = qNormalizedSender;
+        } else {
+            qSenderJid = qNormalizedSender;
+        }
+
+        m.quoted = {
+            id: ctx.stanzaId || "",
+            chat: m.chat,
+            sender: qSenderJid,
+            senderJid: qSenderJid,
+            senderLid: qSenderLid,
+            fromMe:
+                qNormalizedSender ===
+                (0, jid_utils_1.jidNormalizedUser)(msg.key?.fromMe ? m.senderJid : (sock?.user?.id || "")),
+            mtype: qType,
+            text: extractText(qMsg, qType),
+            body: extractText(qMsg, qType),
+            message: qMsg,
+            key: {
+                remoteJid: m.chat,
+                fromMe:
+                    qNormalizedSender ===
+                    (0, jid_utils_1.jidNormalizedUser)(msg.key?.fromMe ? m.senderJid : (sock?.user?.id || "")),
+                id: ctx.stanzaId,
+                participant: m.isGroup ? ctx.participant : undefined
+            },
+            mentionedJid: qInner?.contextInfo?.mentionedJid || [],
+            device: getDevice(ctx.stanzaId),
+
+            // Method: Delete Quoted
+            delete: async (customSock = sock) => {
+                if (!customSock) throw new Error("Socket instance is required for delete");
+                return customSock.sendMessage(m.chat, { delete: m.quoted.key });
+            },
+
+            // Method: Download Quoted Media
+            download: async () => {
+                const mediaContent =
+                    qMsg.imageMessage ||
+                    qMsg.videoMessage ||
+                    qMsg.audioMessage ||
+                    qMsg.stickerMessage ||
+                    qMsg.documentMessage ||
+                    qMsg.viewOnceMessage?.message?.imageMessage ||
+                    qMsg.viewOnceMessage?.message?.videoMessage ||
+                    qMsg.viewOnceMessageV2?.message?.imageMessage ||
+                    qMsg.viewOnceMessageV2?.message?.videoMessage;
+
+                if (!mediaContent) throw new Error("Quoted message is not a media message");
+
+                const messages_media = require("./messages-media");
+                const mediaType = qMsg.imageMessage
+                    ? "image"
+                    : qMsg.videoMessage
+                    ? "video"
+                    : qMsg.audioMessage
+                    ? "audio"
+                    : qMsg.stickerMessage
+                    ? "sticker"
+                    : "document";
+
+                const stream = await messages_media.downloadContentFromMessage(mediaContent, mediaType);
+                return toBuffer(stream);
+            }
+        };
+    }
+
+    // Attach shortcut action helpers to m if sock is passed
+    if (sock) {
+        m.reply = (text, options = {}) => {
+            return sock.sendMessage(
+                m.chat,
+                {
+                    text,
+                    mentions: options.mentions || [m.senderJid],
+                    ...options
+                },
+                { quoted: options.quoted || msg }
+            );
+        };
+
+        m.react = (emoji) => {
+            return sock.sendMessage(m.chat, {
+                react: {
+                    text: emoji,
+                    key: msg.key
+                }
+            });
+        };
+    }
+
+    return m;
+}
+
+exports.default = serialize;

package/lib/Utils/signal.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNextPreKeysNode = exports.getNextPreKeys = exports.extractDeviceJids = exports.parseAndInjectE2ESessions = exports.xmppPreKey = exports.xmppSignedPreKey = exports.generateOrGetPreKeys = exports.getPreKeys = exports.createSignalIdentity = void 0;
+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: (0, crypto_1.generateSignalPubKey)(accountSignatureKey)
+    };
+};
+exports.createSignalIdentity = createSignalIdentity;
+const getPreKeys = async ({ get }, min, limit) => {
+    const idList = [];
+    for (let id = min; id < limit; id++) {
+        idList.push(id.toString());
+    }
+    return get('pre-key', idList);
+};
+exports.getPreKeys = getPreKeys;
+const generateOrGetPreKeys = (creds, range) => {
+    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();
+        }
+    }
+    return {
+        newPreKeys,
+        lastPreKeyId,
+        preKeysRange: [creds.firstUnuploadedPreKeyId, range],
+    };
+};
+exports.generateOrGetPreKeys = generateOrGetPreKeys;
+const xmppSignedPreKey = (key) => ({
+    tag: 'skey',
+    attrs: {},
+    content: [
+        { tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(key.keyId, 3) },
+        { tag: 'value', attrs: {}, content: key.keyPair.public },
+        { tag: 'signature', attrs: {}, content: key.signature }
+    ]
+});
+exports.xmppSignedPreKey = xmppSignedPreKey;
+const xmppPreKey = (pair, id) => ({
+    tag: 'key',
+    attrs: {},
+    content: [
+        { tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(id, 3) },
+        { tag: 'value', attrs: {}, content: pair.public }
+    ]
+});
+exports.xmppPreKey = xmppPreKey;
+const parseAndInjectE2ESessions = async (node, repository) => {
+    const extractKey = (key) => (key ? ({
+        keyId: (0, WABinary_1.getBinaryNodeChildUInt)(key, 'id', 3),
+        publicKey: (0, crypto_1.generateSignalPubKey)((0, WABinary_1.getBinaryNodeChildBuffer)(key, 'value')),
+        signature: (0, WABinary_1.getBinaryNodeChildBuffer)(key, 'signature'),
+    }) : undefined);
+    const nodes = (0, WABinary_1.getBinaryNodeChildren)((0, WABinary_1.getBinaryNodeChild)(node, 'list'), 'user');
+    for (const node of nodes) {
+        (0, WABinary_1.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 = (0, lodash_1.chunk)(nodes, chunkSize);
+    for (const nodesChunk of chunks) {
+        await Promise.all(nodesChunk.map(async (node) => {
+            const signedKey = (0, WABinary_1.getBinaryNodeChild)(node, 'skey');
+            const key = (0, WABinary_1.getBinaryNodeChild)(node, 'key');
+            const identity = (0, WABinary_1.getBinaryNodeChildBuffer)(node, 'identity');
+            const jid = node.attrs.jid;
+            const registrationId = (0, WABinary_1.getBinaryNodeChildUInt)(node, 'registration', 4);
+            await repository.injectE2ESession({
+                jid,
+                session: {
+                    registrationId: registrationId,
+                    identityKey: (0, crypto_1.generateSignalPubKey)(identity),
+                    signedPreKey: extractKey(signedKey),
+                    preKey: extractKey(key)
+                }
+            });
+        }));
+    }
+};
+exports.parseAndInjectE2ESessions = parseAndInjectE2ESessions;
+const extractDeviceJids = (result, myJid, excludeZeroDevices) => {
+    const { user: myUser, device: myDevice } = (0, WABinary_1.jidDecode)(myJid);
+    const extracted = [];
+    for (const userResult of result) {
+        const { devices, id } = userResult;
+        const { user } = (0, WABinary_1.jidDecode)(id);
+        const deviceList = devices === null || devices === void 0 ? void 0 : 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 });
+                }
+            }
+        }
+    }
+    return extracted;
+};
+exports.extractDeviceJids = extractDeviceJids;
+/**
+ * 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 } = (0, exports.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 (0, exports.getPreKeys)(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1]);
+    return { update, preKeys };
+};
+exports.getNextPreKeys = getNextPreKeys;
+const getNextPreKeysNode = async (state, count) => {
+    const { creds } = state;
+    const { update, preKeys } = await (0, exports.getNextPreKeys)(state, count);
+    const node = {
+        tag: 'iq',
+        attrs: {
+            xmlns: 'encrypt',
+            type: 'set',
+            to: WABinary_1.S_WHATSAPP_NET,
+        },
+        content: [
+            { tag: 'registration', attrs: {}, content: (0, 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 => (0, exports.xmppPreKey)(preKeys[+k], +k)) },
+            (0, exports.xmppSignedPreKey)(creds.signedPreKey)
+        ]
+    };
+    return { update, node };
+};
+exports.getNextPreKeysNode = getNextPreKeysNode;

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

@@ -0,0 +1,124 @@
+"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 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/Rixleys/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
+const getFileLock = (path) => {
+    let mutex = fileLocks.get(path);
+    if (!mutex) {
+        mutex = new async_mutex_1.Mutex();
+        fileLocks.set(path, mutex);
+    }
+    return mutex;
+};
+/**
+ * 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) => {
+        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 (_a) {
+                }
+                finally {
+                    release();
+                }
+            });
+        }
+        catch (_a) {
+        }
+    };
+    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) {
+                            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`;
+                            tasks.push(value ? writeData(value, file) : removeData(file));
+                        }
+                    }
+                    await Promise.all(tasks);
+                }
+            }
+        },
+        saveCreds: async () => {
+            return writeData(creds, 'creds.json');
+        }
+    };
+};
+exports.useMultiFileAuthState = useMultiFileAuthState;