@crysnovax/baileys 2.5.6 → 2.6.1

package/lib/Utils/signal.js

@@ -55,6 +55,48 @@ export const xmppPreKey = (pair, id) => ({
         { tag: 'value', attrs: {}, content: pair.public }
     ]
 });
+const isValidUInt = (n) => typeof n === 'number' && Number.isInteger(n);
+export const extractE2ESessionFromRetryReceipt = (receipt) => {
+    const keysNode = getBinaryNodeChild(receipt, 'keys');
+    if (!keysNode)
+        return null;
+    const typeBuf = getBinaryNodeChildBuffer(keysNode, 'type');
+    if (!typeBuf || typeBuf.length !== 1 || typeBuf[0] !== KEY_BUNDLE_TYPE[0])
+        return null;
+    const identity = getBinaryNodeChildBuffer(keysNode, 'identity');
+    const skey = getBinaryNodeChild(keysNode, 'skey');
+    if (!identity || identity.length !== 32 || !skey)
+        return null;
+    const registrationId = getBinaryNodeChildUInt(receipt, 'registration', 4);
+    if (!isValidUInt(registrationId))
+        return null;
+    const signedPubKey = getBinaryNodeChildBuffer(skey, 'value');
+    const signedSig = getBinaryNodeChildBuffer(skey, 'signature');
+    const signedKeyId = getBinaryNodeChildUInt(skey, 'id', 3);
+    if (!signedPubKey || signedPubKey.length !== 32 || !signedSig || !isValidUInt(signedKeyId)) {
+        return null;
+    }
+    const preKeyNode = getBinaryNodeChild(keysNode, 'key');
+    let preKey;
+    if (preKeyNode) {
+        const preKeyPub = getBinaryNodeChildBuffer(preKeyNode, 'value');
+        const preKeyId = getBinaryNodeChildUInt(preKeyNode, 'id', 3);
+        if (!preKeyPub || preKeyPub.length !== 32 || !isValidUInt(preKeyId)) {
+            return null;
+        }
+        preKey = { keyId: preKeyId, publicKey: generateSignalPubKey(preKeyPub) };
+    }
+    return {
+        registrationId,
+        identityKey: generateSignalPubKey(identity),
+        signedPreKey: {
+            keyId: signedKeyId,
+            publicKey: generateSignalPubKey(signedPubKey),
+            signature: signedSig
+        },
+        preKey
+    };
+};
 export const parseAndInjectE2ESessions = async (node, repository) => {
     const extractKey = (key) => key
         ? {
@@ -155,4 +197,4 @@ export const getNextPreKeysNode = async (state, count) => {
         ]
     };
     return { update, node };
-};
+};

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

@@ -1,9 +1,119 @@
-export async function buildTcTokenFromJid({ authState, jid, baseContent = [] }) {
+import { getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidMetaAI, isLidUser, isPnUser, jidNormalizedUser } from '../WABinary/index.js';
+// Same phone-number pattern as WABinary's isJidBot, applied against the user
+// part so the check is invariant to @c.us ↔ @s.whatsapp.net normalization.
+const BOT_PHONE_REGEX = /^1313555\d{4}$|^131655500\d{2}$/;
+/**
+ * Mirrors WA Web's `Wid.isRegularUser()` (user ∧ ¬PSA ∧ ¬Bot). Used to gate tctoken
+ * storage against malformed notifications — WA Web filters server-side but we
+ * defend here for parity with `WAWebSetTcTokenChatAction.handleIncomingTcToken`.
+ * Works for both pre- and post-normalized JIDs (`@c.us` vs `@s.whatsapp.net`).
+ */
+function isRegularUser(jid) {
+    if (!jid)
+        return false;
+    const user = jid.split('@')[0] ?? '';
+    if (user === '0')
+        return false; // PSA
+    if (BOT_PHONE_REGEX.test(user))
+        return false; // Bot by phone pattern
+    if (isJidMetaAI(jid))
+        return false; // MetaAI (@bot server)
+    return !!(isPnUser(jid) || isLidUser(jid) || isHostedPnUser(jid) || isHostedLidUser(jid) || jid.endsWith('@c.us'));
+}
+const TC_TOKEN_BUCKET_DURATION = 604800; // 7 days
+const TC_TOKEN_NUM_BUCKETS = 4; // ~28-day rolling window
+/** Sentinel key under `tctoken` store holding a JSON array of tracked storage JIDs for cross-session pruning. */
+export const TC_TOKEN_INDEX_KEY = '__index';
+/** Read the persisted tctoken JID index and return its entries (never contains the sentinel key itself). */
+export async function readTcTokenIndex(keys) {
+    const data = await keys.get('tctoken', [TC_TOKEN_INDEX_KEY]);
+    const entry = data[TC_TOKEN_INDEX_KEY];
+    if (!entry?.token?.length)
+        return [];
     try {
-        const tcTokenData = await authState.keys.get('tctoken', [jid]);
-        const tcTokenBuffer = tcTokenData?.[jid]?.token;
-        if (!tcTokenBuffer)
+        const parsed = JSON.parse(Buffer.from(entry.token).toString());
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter((j) => typeof j === 'string' && j.length > 0 && j !== TC_TOKEN_INDEX_KEY);
+    }
+    catch {
+        return [];
+    }
+}
+/** Build a SignalDataSet fragment that writes the merged index (persisted ∪ added) under the sentinel key. */
+export async function buildMergedTcTokenIndexWrite(keys, addedJids) {
+    const persisted = await readTcTokenIndex(keys);
+    const merged = new Set(persisted);
+    for (const jid of addedJids) {
+        if (jid && jid !== TC_TOKEN_INDEX_KEY)
+            merged.add(jid);
+    }
+    return {
+        [TC_TOKEN_INDEX_KEY]: { token: Buffer.from(JSON.stringify([...merged])) }
+    };
+}
+// WA Web has separate sender/receiver AB props for these but they're identical today
+export function isTcTokenExpired(timestamp) {
+    if (timestamp === null || timestamp === undefined)
+        return true;
+    const ts = typeof timestamp === 'string' ? parseInt(timestamp) : timestamp;
+    if (isNaN(ts))
+        return true;
+    const now = Math.floor(Date.now() / 1000);
+    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION);
+    const cutoffBucket = currentBucket - (TC_TOKEN_NUM_BUCKETS - 1);
+    const cutoffTimestamp = cutoffBucket * TC_TOKEN_BUCKET_DURATION;
+    return ts < cutoffTimestamp;
+}
+export function shouldSendNewTcToken(senderTimestamp) {
+    if (senderTimestamp === undefined)
+        return true;
+    const now = Math.floor(Date.now() / 1000);
+    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION);
+    const senderBucket = Math.floor(senderTimestamp / TC_TOKEN_BUCKET_DURATION);
+    return currentBucket > senderBucket;
+}
+/** Resolve JID to LID for tctoken storage (WA Web stores under LID) */
+export async function resolveTcTokenJid(jid, getLIDForPN) {
+    if (isLidUser(jid))
+        return jid;
+    const lid = await getLIDForPN(jid);
+    return lid ?? jid;
+}
+/** Resolve target JID for issuing privacy token based on AB prop 14303 */
+export async function resolveIssuanceJid(jid, issueToLid, getLIDForPN, getPNForLID) {
+    if (issueToLid) {
+        if (isLidUser(jid))
+            return jid;
+        const lid = await getLIDForPN(jid);
+        return lid ?? jid;
+    }
+    if (!isLidUser(jid))
+        return jid;
+    if (getPNForLID) {
+        const pn = await getPNForLID(jid);
+        return pn ?? jid;
+    }
+    return jid;
+}
+export async function buildTcTokenFromJid({ authState, jid, baseContent = [], getLIDForPN }) {
+    try {
+        const storageJid = await resolveTcTokenJid(jid, getLIDForPN);
+        const tcTokenData = await authState.keys.get('tctoken', [storageJid]);
+        const entry = tcTokenData?.[storageJid];
+        const tcTokenBuffer = entry?.token;
+        if (!tcTokenBuffer?.length || isTcTokenExpired(entry?.timestamp)) {
+            if (tcTokenBuffer) {
+                // Preserve senderTimestamp so shouldSendNewTcToken() keeps its dedupe state
+                // after we drop the unusable peer token. Only wipe the record entirely when
+                // there's nothing worth keeping.
+                const cleared = entry?.senderTimestamp !== undefined
+                    ? { token: Buffer.alloc(0), senderTimestamp: entry.senderTimestamp }
+                    : null;
+                await authState.keys.set({ tctoken: { [storageJid]: cleared } });
+            }
             return baseContent.length > 0 ? baseContent : undefined;
+        }
         baseContent.push({
             tag: 'tctoken',
             attrs: {},
@@ -14,4 +124,39 @@ export async function buildTcTokenFromJid({ authState, jid, baseContent = [] })
     catch (error) {
         return baseContent.length > 0 ? baseContent : undefined;
     }
-}
+}
+export async function storeTcTokensFromIqResult({ result, fallbackJid, keys, getLIDForPN, onNewJidStored }) {
+    const tokensNode = getBinaryNodeChild(result, 'tokens');
+    if (!tokensNode)
+        return;
+    const tokenNodes = getBinaryNodeChildren(tokensNode, 'token');
+    for (const tokenNode of tokenNodes) {
+        if (tokenNode.attrs.type !== 'trusted_contact' || !(tokenNode.content instanceof Uint8Array)) {
+            continue;
+        }
+        // In notifications tokenNode.attrs.jid is your own device JID, not the sender's
+        const rawJid = jidNormalizedUser(fallbackJid || tokenNode.attrs.jid);
+        if (!isRegularUser(rawJid))
+            continue;
+        const storageJid = await resolveTcTokenJid(rawJid, getLIDForPN);
+        const existingTcData = await keys.get('tctoken', [storageJid]);
+        const existingEntry = existingTcData[storageJid];
+        const existingTs = existingEntry?.timestamp ? Number(existingEntry.timestamp) : 0;
+        const incomingTs = tokenNode.attrs.t ? Number(tokenNode.attrs.t) : 0;
+        // timestamp-less tokens would be immediately expired
+        if (!incomingTs)
+            continue;
+        if (existingTs > 0 && existingTs > incomingTs)
+            continue;
+        await keys.set({
+            tctoken: {
+                [storageJid]: {
+                    ...existingEntry,
+                    token: Buffer.from(tokenNode.content),
+                    timestamp: tokenNode.attrs.t
+                }
+            }
+        });
+        onNewJidStored?.(storageJid);
+    }
+}

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

@@ -0,0 +1,108 @@
+import { mkdir, readFile, stat, unlink, writeFile } from 'fs/promises';
+import { join } from 'path';
+import { proto } from '../../WAProto/index.js';
+import { initAuthCreds } from './auth-utils.js';
+import { BufferJSON } from './generics.js';
+async function loadBetterSqlite3() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const mod = (await import('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);
+`;
+export 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);
+    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 initAuthCreds();
+        return JSON.parse(row.value, BufferJSON.reviver);
+    };
+    const persistCreds = (creds) => {
+        stmts.credsUpsert.run(CREDS_ROW_KEY, JSON.stringify(creds, 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, BufferJSON.reviver);
+                            if (type === 'app-state-sync-key' && value) {
+                                value = 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, BufferJSON.replacer);
+                                    stmts.keyUpsert.run(category, id, stringified);
+                                }
+                                else {
+                                    stmts.keyDelete.run(category, id);
+                                }
+                            }
+                        }
+                    });
+                    writeTx();
+                }
+            }
+        },
+        saveCreds: async () => {
+            persistCreds(creds);
+        }
+    };
+}

package/lib/WABinary/constants.js

@@ -1354,6 +1354,86 @@ export const RUST_KEYWORDS = new Set([
     'where', 'while', 'async', 'await', 'dyn', 'abstract', 'become', 'box', 'do', 'final',
     'macro', 'override', 'priv', 'typeof', 'unsized', 'virtual', 'yield'
 ]);
+export const C_KEYWORDS = new Set([
+    'auto', 'break', 'case', 'char', 'const', 'continue',
+    'default', 'do', 'double', 'else', 'enum', 'extern',
+    'float', 'for', 'goto', 'if', 'inline', 'int',
+    'long', 'register', 'restrict', 'return', 'short',
+    'signed', 'sizeof', 'static', 'struct', 'switch',
+    'typedef', 'union', 'unsigned', 'void', 'volatile',
+    'while',
+    '_Alignas', '_Alignof', '_Atomic', '_Bool',
+    '_Complex', '_Generic', '_Imaginary',
+    '_Noreturn', '_Static_assert', '_Thread_local'
+]);
+export const CSHARP_KEYWORDS = new Set([
+    'abstract', 'as', 'base', 'bool', 'break', 'byte',
+    'case', 'catch', 'char', 'checked', 'class',
+    'const', 'continue', 'decimal', 'default',
+    'delegate', 'do', 'double', 'else', 'enum',
+    'event', 'explicit', 'extern', 'false', 'finally',
+    'fixed', 'float', 'for', 'foreach', 'goto',
+    'if', 'implicit', 'in', 'int', 'interface',
+    'internal', 'is', 'lock', 'long', 'namespace',
+    'new', 'null', 'object', 'operator', 'out',
+    'override', 'params', 'private', 'protected',
+    'public', 'readonly', 'ref', 'return', 'sbyte',
+    'sealed', 'short', 'sizeof', 'stackalloc',
+    'static', 'string', 'struct', 'switch',
+    'this', 'throw', 'true', 'try', 'typeof',
+    'uint', 'ulong', 'unchecked', 'unsafe',
+    'ushort', 'using', 'virtual', 'void',
+    'volatile', 'while',
+    'async', 'await', 'record', 'init',
+    'required', 'file', 'global', 'nameof',
+    'var', 'dynamic', 'partial', 'yield',
+    'from', 'where', 'select', 'group',
+    'orderby', 'join', 'let', 'into',
+    'equals', 'by', 'ascending', 'descending'
+]);
+export const BASH_KEYWORDS = new Set([
+    'if', 'then', 'else', 'elif', 'fi',
+    'case', 'esac', 'for', 'while',
+    'until', 'do', 'done', 'in',
+    'function', 'select', 'time',
+    'coproc',
+    'echo', 'printf', 'read', 'cd',
+    'pwd', 'exit', 'export', 'unset',
+    'alias', 'unalias', 'source',
+    'exec', 'eval', 'test', 'shift',
+    'trap', 'wait', 'jobs', 'kill',
+    'bg', 'fg', 'history', 'type',
+    'ulimit', 'umask', 'set',
+    'true', 'false'
+]);
+export const CMD_KEYWORDS = new Set([
+    'echo', 'set', 'if', 'else',
+    'for', 'in', 'do', 'goto',
+    'call', 'exit', 'shift',
+    'pause', 'start', 'title',
+    'cls', 'rem',
+    'dir', 'copy', 'move', 'del',
+    'mkdir', 'rmdir', 'type',
+    'ren', 'tasklist', 'taskkill',
+    'ping', 'ipconfig', 'netstat',
+    'shutdown'
+]);
+export const POWERSHELL_KEYWORDS = new Set([
+    'function', 'filter', 'param',
+    'begin', 'process', 'end',
+    'if', 'else', 'elseif',
+    'switch', 'foreach', 'for',
+    'while', 'do', 'until',
+    'break', 'continue', 'return',
+    'throw', 'trap', 'try',
+    'catch', 'finally',
+    '$true', '$false', '$null',
+    'Write-Host', 'Write-Output',
+    'Get-Item', 'Set-Item',
+    'Get-ChildItem', 'Remove-Item',
+    'Copy-Item', 'Move-Item',
+    'Test-Path', 'Invoke-Command'
+]);
 export const LANGUAGE_KEYWORDS = {
     css: CSS_KEYWORDS,
     html: HTML_KEYWORDS,
@@ -1369,4 +1449,15 @@ export const LANGUAGE_KEYWORDS = {
     'c++': CPP_KEYWORDS,
     rust: RUST_KEYWORDS,
     rs: RUST_KEYWORDS,
+    c: C_KEYWORDS,
+    h: C_KEYWORDS,
+    csharp: CSHARP_KEYWORDS,
+    cs: CSHARP_KEYWORDS,
+    bash: BASH_KEYWORDS,
+    sh: BASH_KEYWORDS,
+    zsh: BASH_KEYWORDS,
+    cmd: CMD_KEYWORDS,
+    bat: CMD_KEYWORDS,
+    powershell: POWERSHELL_KEYWORDS,
+    ps1: POWERSHELL_KEYWORDS
 };

package/package.json

@@ -1,7 +1,7 @@
 {
    "name": "@crysnovax/baileys",
-   "version": "2.5.6",
-   "description": "Premium Baileys fork — Meta compositing, bot planning replay, welcome flow, rich messages (code, table, LaTeX, reels), interactive messages, albums, and more.",
+   "version": "2.6.1",
+   "description": "Premium Baileys fork ⚉ Meta compositing, bot planning replay, welcome flow, rich messages (code, table, LaTeX, reels), interactive messages, albums, and more.",
    "main": "lib/index.js",
    "type": "module",
    "scripts": {
@@ -25,6 +25,7 @@
       "baileys-fork",
       "baileys-mod",
       "crysnova ai",
+      "cody ai",
       "bot-planning-replay",
       "crysnovax",
       "interactive-messages",
@@ -40,7 +41,7 @@
       "whatsapp-group",
       "whatsapp-web"
    ],
-   "homepage": "https://web.crysnovax.link",
+   "homepage": "https://www.npmjs.com/package/@crysnovax/baileys/",
    "author": "crysnovax",
    "license": "MIT",
    "dependencies": {
@@ -49,21 +50,22 @@
       "@hapi/boom": "^9.1.3",
       "async-mutex": "^0.5.0",
       "fflate": "^0.8.2",
-      "libsignal": "github:WhiskeySockets/libsignal-wasm#master",
+      "libsignal": "^6.0.0",
       "lru-cache": "^11.2.6",
-      "music-metadata": "^11.7.0",
+      "music-metadata": "^11.12.3",
       "p-queue": "^9.1.0",
       "pino": "^9.6.0",
-      "protobufjs": "^7.5.4",
-      "whatsapp-rust-bridge": "0.5.3",
+      "protobufjs": "^7.5.6",
+      "whatsapp-rust-bridge": "0.5.5",
       "ws": "^8.19.0"
    },
    "peerDependencies": {
       "@napi-rs/image": "~1.12.0",
       "audio-decode": "^2.2.3",
-      "jimp": "^1.6.0",
+      "jimp": "^1.6.1",
       "link-preview-js": "^3.0.0",
-      "sharp": "*"
+      "sharp": "*",
+      "better-sqlite3": "^11.0.0"
    },
    "peerDependenciesMeta": {
       "@napi-rs/image": {
@@ -77,7 +79,40 @@
       },
       "link-preview-js": {
          "optional": true
+      },
+      "better-sqlite3": {
+         "optional": true
       }
    },
-   "packageManager": "yarn@4.9.2"
+   "packageManager": "yarn@4.9.2",
+   "types": "lib/index.d.ts",
+   "resolutions": {
+      "ajv@npm:^6.12.4": "^6.14.0",
+      "basic-ftp": "^5.2.4",
+      "brace-expansion@npm:^1.1.7": "^1.1.13",
+      "brace-expansion@npm:^2.0.1": "^2.0.3",
+      "flatted": "^3.4.2",
+      "glob@npm:^10.2.2": "^10.5.0",
+      "glob@npm:^10.3.10": "^10.5.0",
+      "glob@npm:^10.5.0": "^10.5.0",
+      "handlebars": "^4.7.9",
+      "ip-address": "^10.1.1",
+      "js-yaml@npm:^3.13.1": "^3.14.2",
+      "js-yaml@npm:^4.1.0": "^4.1.1",
+      "markdown-it": "^14.1.1",
+      "minimatch@npm:^3.0.4": "^3.1.5",
+      "minimatch@npm:^3.1.2": "^3.1.5",
+      "minimatch@npm:^5.0.1": "^5.1.8",
+      "minimatch@npm:^9.0.4": "^9.0.9",
+      "minimatch@npm:^9.0.5": "^9.0.9",
+      "picomatch@npm:^2.0.4": "^2.3.2",
+      "picomatch@npm:^2.3.1": "^2.3.2",
+      "picomatch@npm:^4.0.0": "^4.0.4",
+      "picomatch@npm:^4.0.2": "^4.0.4",
+      "socks": "^2.8.8",
+      "tar": "^7.5.11",
+      "tmp": "^0.2.5",
+      "underscore": "^1.13.8",
+      "yaml@npm:^2.6.1": "^2.8.4"
+   }
 }