@ryuu-reinzz/baileys 3.0.0-beta.2 → 3.0.0-beta.21

package/lib/Utils/sync-action-utils.js

@@ -0,0 +1,48 @@
+import { proto } from '../../WAProto/index.js';
+import { isLidUser, isPnUser } from '../WABinary/index.js';
+/**
+ * Process contactAction and return events to emit.
+ * Pure function - no side effects.
+ */
+export const processContactAction = (action, id, logger) => {
+    const results = [];
+    if (!id) {
+        logger?.warn({ hasFullName: !!action.fullName, hasLidJid: !!action.lidJid, hasPnJid: !!action.pnJid }, 'contactAction sync: missing id in index');
+        return results;
+    }
+    const lidJid = action.lidJid;
+    const idIsPn = isPnUser(id);
+    // PN is in index[1], not in contactAction.pnJid which is usually null
+    const phoneNumber = idIsPn ? id : action.pnJid || undefined;
+    // Always emit contacts.upsert
+    results.push({
+        event: 'contacts.upsert',
+        data: [
+            {
+                id,
+                name: action.fullName || action.firstName || action.username || undefined,
+                lid: lidJid || undefined,
+                phoneNumber
+            }
+        ]
+    });
+    // Emit lid-mapping.update if we have valid LID-PN pair
+    if (lidJid && isLidUser(lidJid) && idIsPn) {
+        results.push({
+            event: 'lid-mapping.update',
+            data: { lid: lidJid, pn: id }
+        });
+    }
+    return results;
+};
+export const emitSyncActionResults = (ev, results) => {
+    for (const result of results) {
+        if (result.event === 'contacts.upsert') {
+            ev.emit('contacts.upsert', result.data);
+        }
+        else {
+            ev.emit('lid-mapping.update', result.data);
+        }
+    }
+};
+//# sourceMappingURL=sync-action-utils.js.map

package/lib/Utils/tc-token-utils.js

@@ -0,0 +1,18 @@
+export async function buildTcTokenFromJid({ authState, jid, baseContent = [] }) {
+    try {
+        const tcTokenData = await authState.keys.get('tctoken', [jid]);
+        const tcTokenBuffer = tcTokenData?.[jid]?.token;
+        if (!tcTokenBuffer)
+            return baseContent.length > 0 ? baseContent : undefined;
+        baseContent.push({
+            tag: 'tctoken',
+            attrs: {},
+            content: tcTokenBuffer
+        });
+        return baseContent;
+    }
+    catch (error) {
+        return baseContent.length > 0 ? baseContent : undefined;
+    }
+}
+//# sourceMappingURL=tc-token-utils.js.map

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

@@ -0,0 +1,122 @@
+/**
+ * Custom SQLite Auth Store untuk Baileys
+ * by Ryuu
+ */
+
+import Database from "better-sqlite3";
+import { proto } from '../../WAProto/index.js';
+import { initAuthCreds } from './auth-utils.js';
+import { BufferJSON } from './generics.js';
+import fs from 'fs';
+/**
+ * Membuat atau mengambil auth state dari SQLite
+ * @param {string} folder - Lokasi file SQLite (contoh: "./auth.db")
+ */
+export const useSQLiteAuthState = async (folder) => {
+  if (!folder) {
+      throw new Error('Path required')
+    };
+  if (!fs.existsSync(folder)) {
+       fs.mkdirSync(folder, { recursive: true })
+     };
+  if (folder.endsWith("/")) {
+      folder += "auth.db"
+    } else {
+      folder += "/auth.db"
+    }
+    const db = new Database(folder);
+    db.pragma("journal_mode = WAL");
+
+    db.prepare(`
+    CREATE TABLE IF NOT EXISTS baileys_state (
+      key TEXT PRIMARY KEY,
+      value BLOB
+    )
+  `).run();
+
+    const load = (key) => {
+        const row = db.prepare("SELECT value FROM baileys_state WHERE key = ?").get(key);
+        if (!row) return null;
+        try {
+            return JSON.parse(row.value.toString(), BufferJSON.reviver);
+        } catch {
+            return null;
+        }
+    };
+
+    const save = (key, data) => {
+        const json = JSON.stringify(data, BufferJSON.replacer);
+        const buf = Buffer.from(json, "utf8");
+        db.prepare("REPLACE INTO baileys_state (key, value) VALUES (?, ?)").run(key, buf);
+    };
+
+    const creds = load("creds") || initAuthCreds();
+
+    const keys = {};
+    const categories = [
+        "pre-key",
+        "session",
+        "sender-key",
+        "app-state-sync-key",
+        "app-state-sync-version"
+    ];
+
+    for (const category of categories) {
+        keys[category] = {};
+        const rows = db
+            .prepare("SELECT key, value FROM baileys_state WHERE key LIKE ?")
+            .all(`${category}:%`);
+        for (const row of rows) {
+            try {
+                keys[category][row.key.slice(category.length + 1)] = JSON.parse(row.value.toString());
+            } catch {}
+        }
+    }
+
+    async function saveCreds() {
+        save("creds", creds);
+    }
+
+    const set = (category, id, value) => {
+        const key = `${category}:${id}`;
+        save(key, value);
+    };
+
+    const get = (category, id) => {
+        const key = `${category}:${id}`;
+        return load(key);
+    };
+
+    const del = (category, id) => {
+        const key = `${category}:${id}`;
+        db.prepare("DELETE FROM baileys_state WHERE key = ?").run(key);
+    };
+
+    return {
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids) => {
+                    const data = {};
+                    for (const id of ids) {
+                        const value = load(`${type}:${id}`);
+                        if (value) data[id] = value;
+                    }
+                    return data;
+                },
+                set: async (data) => {
+                    for (const category in data) {
+                        for (const id in data[category]) {
+                            const value = data[category][id];
+                            save(`${category}:${id}`, value);
+                        }
+                    }
+                }
+            }
+        },
+        saveCreds: async () => save("creds", creds)
+    };
+    setInterval(async () => {
+        await save("creds", creds);
+    }, 30_000);
+}

package/lib/WABinary/decode.js

@@ -136,6 +136,26 @@ export const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0
         }
         return jidEncode(user, server, device);
     };
+    const readFbJid = () => {
+        const user = readString(readByte());
+        const device = readInt(2);
+        const server = readString(readByte());
+        return `${user}:${device}@${server}`;
+    };
+    const readInteropJid = () => {
+        const user = readString(readByte());
+        const device = readInt(2);
+        const integrator = readInt(2);
+        let server = 'interop';
+        const beforeServer = indexRef.index;
+        try {
+            server = readString(readByte());
+        }
+        catch (err) {
+            indexRef.index = beforeServer;
+        }
+        return `${integrator}-${user}:${device}@${server}`;
+    };
     const readString = (tag) => {
         if (tag >= 1 && tag < SINGLE_BYTE_TOKENS.length) {
             return SINGLE_BYTE_TOKENS[tag] || '';
@@ -156,6 +176,10 @@ export const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0
                 return readStringFromChars(readInt(4));
             case TAGS.JID_PAIR:
                 return readJidPair();
+            case TAGS.FB_JID:
+                return readFbJid();
+            case TAGS.INTEROP_JID:
+                return readInteropJid();
             case TAGS.AD_JID:
                 return readAdJid();
             case TAGS.HEX_8:

package/lib/WABinary/encode.js

@@ -144,6 +144,10 @@ const encodeBinaryNodeInner = ({ tag, attrs, content }, opts, buffer) => {
             pushByte(TAGS.LIST_EMPTY);
             return;
         }
+        if (str === '') {
+            writeStringRaw(str);
+            return;
+        }
         const tokenIndex = TOKEN_MAP[str];
         if (tokenIndex) {
             if (typeof tokenIndex.dict === 'number') {
@@ -157,7 +161,7 @@ const encodeBinaryNodeInner = ({ tag, attrs, content }, opts, buffer) => {
         else if (isHex(str)) {
             writePackedBytes(str, 'hex');
         }
-        else if (str) {
+        else {
             const decodedJid = jidDecode(str);
             if (decodedJid) {
                 writeJid(decodedJid);

package/lib/WABinary/generic-utils.js

@@ -2,11 +2,27 @@ import { Boom } from '@hapi/boom';
 import { proto } from '../../WAProto/index.js';
 import {} from './types.js';
 // some extra useful utilities
+const indexCache = new WeakMap();
 export const getBinaryNodeChildren = (node, childTag) => {
-    if (Array.isArray(node?.content)) {
-        return node.content.filter(item => item.tag === childTag);
+    if (!node || !Array.isArray(node.content))
+        return [];
+    let index = indexCache.get(node);
+    // Build the index once per node
+    if (!index) {
+        index = new Map();
+        for (const child of node.content) {
+            let arr = index.get(child.tag);
+            if (!arr)
+                index.set(child.tag, (arr = []));
+            arr.push(child);
+        }
+        indexCache.set(node, index);
     }
-    return [];
+    // Return first matching child
+    return index.get(childTag) || [];
+};
+export const getBinaryNodeChild = (node, childTag) => {
+    return getBinaryNodeChildren(node, childTag)[0];
 };
 export const getAllBinaryNodeChildren = ({ content }) => {
     if (Array.isArray(content)) {
@@ -14,11 +30,6 @@ export const getAllBinaryNodeChildren = ({ content }) => {
     }
     return [];
 };
-export const getBinaryNodeChild = (node, childTag) => {
-    if (Array.isArray(node?.content)) {
-        return node?.content.find(item => item.tag === childTag);
-    }
-};
 export const getBinaryNodeChildBuffer = (node, childTag) => {
     const child = getBinaryNodeChild(node, childTag)?.content;
     if (Buffer.isBuffer(child) || child instanceof Uint8Array) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ryuu-reinzz/baileys",
   "type": "module",
-  "version": "3.0.0-beta.2",
+  "version": "3.0.0-beta.21",
   "description": "A WebSockets library for interacting with WhatsApp Web",
   "keywords": [
     "whatsapp",
@@ -20,17 +20,22 @@
     "WAProto/**/*",
     "engine-requirements.js"
   ],
+  "scripts": {
+    "start": "node engine-requirements.js"
+  },  
   "dependencies": {
     "@cacheable/node-cache": "^1.4.0",
-    "@ryuu-reinzz/haruka-lib": "^3.2.0",
+    "@ryuu-reinzz/haruka-lib": "^3.2.3",
     "@hapi/boom": "^9.1.3",
     "async-mutex": "^0.5.0",
+    "better-sqlite3": "^12.5.0",
     "libsignal": "git+https://github.com/whiskeysockets/libsignal-node",
     "lru-cache": "^11.1.0",
     "music-metadata": "^11.7.0",
     "p-queue": "^9.0.0",
     "pino": "^9.6",
     "protobufjs": "^7.2.4",
+    "whatsapp-rust-bridge": "0.5.2",
     "ws": "^8.13.0"
   },
   "devDependencies": {