@zervonex/baileys 0.0.0-stage → 3.0.2

package/lib/Socket/spam-report.js

@@ -0,0 +1,65 @@
+import { createReportingInfoStore } from '../Store/index.js'
+import { SPAM_FLOWS, resolveReportJid, normalizeReportingTag, buildSpamReportIq, buildSimpleReportNode, parseSpamReportResponse } from '../Utils/index.js'
+import { isJidGroup, isPnUser, isLidUser, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js'
+
+export const makeSpamReportSocket = (sock, config) => {
+    const { query, signalRepository, updateBlockStatus, logger } = sock
+
+    if (!config.reportingInfoStore) config.reportingInfoStore = createReportingInfoStore()
+    const store = config.reportingInfoStore
+
+    const simpleReportQuery = (jid, messageKeys) => query({
+        tag: 'iq',
+        attrs: { type: 'set', xmlns: 'spam', to: S_WHATSAPP_NET },
+        content: [buildSimpleReportNode(jid, messageKeys)]
+    })
+
+    const reportSpam = async (jid, options = {}) => {
+        const { spamFlow = SPAM_FLOWS.ACCOUNT_INFO_REPORT, messages: manualMessages, maxMessages = 5 } = options
+        const reportJid = await resolveReportJid(jid, signalRepository?.lidMapping)
+        let messages = manualMessages
+        if (!messages?.length) {
+            messages = store.getForJid(reportJid, maxMessages)
+            if (!messages.length) messages = store.getForJid(jid, maxMessages)
+        }
+        if (!messages?.length) throw new Error(`reportSpam: no reporting_tag stored for ${jid}. Receive at least one message first.`)
+        const normalized = messages.slice(0, maxMessages).map(m => ({
+            stanzaId: m.stanzaId || m.id,
+            timestamp: Number(m.timestamp || m.sendTimestamp || m.t),
+            reportingTag: normalizeReportingTag(m.reportingTag || m.tag),
+            text: m.text ?? m.raw ?? '',
+            pushName: m.pushName || m.reportedPushName || '',
+            messageType: m.messageType || m.type || 'text',
+            fromJid: m.fromJid || m.from || reportJid
+        }))
+        logger?.debug?.({ jid: reportJid, spamFlow, count: normalized.length }, 'sending spam report IQ')
+        const result = await query(buildSpamReportIq(reportJid, normalized, spamFlow))
+        return { ...parseSpamReportResponse(result), messageCount: normalized.length }
+    }
+
+    const reportContact = async (jid, messageKeys = []) => {
+        const normalized = jidNormalizedUser(jid)
+        if (!isPnUser(normalized) && !isLidUser(normalized)) throw new Error('reportContact requires a valid contact JID')
+        const result = await simpleReportQuery(normalized, messageKeys)
+        await updateBlockStatus(normalized, 'block')
+        return parseSpamReportResponse(result)
+    }
+
+    const reportGroup = async (jid, messageKeys = []) => {
+        if (!isJidGroup(jid)) throw new Error('reportGroup requires a valid group JID')
+        const result = await simpleReportQuery(jid, messageKeys)
+        await query({ tag: 'iq', attrs: { type: 'set', xmlns: 'w:g2', to: '@g.us' }, content: [{ tag: 'leave', attrs: {}, content: [{ tag: 'group', attrs: { id: jid } }] }] })
+        return parseSpamReportResponse(result)
+    }
+
+    return {
+        ...sock,
+        reportSpam,
+        reportContact,
+        reportGroup,
+        getStoredReportingInfo: (jid, max = 5) => store.getForJid(jid, max),
+        clearStoredReportingInfo: jid => store.clear(jid),
+        reportingInfoStore: store,
+        SPAM_FLOWS
+    }
+}

package/lib/Socket/username.js

@@ -0,0 +1,82 @@
+import { randomUUID } from 'crypto';
+import { executeWMexQuery } from './mex.js';
+import { USyncQuery, USyncUser } from '../WAUSync/index.js';
+import { makeRegistrationSocket } from './registration.js';
+import { makeSpamReportSocket } from './spam-report.js';
+import { USERNAME_QUERY_IDS, USERNAME_CHECK_RESULT, USERNAME_SOURCE } from '../Defaults/index.js';
+
+export const makeUsernameSocket = config => {
+    const sock = makeRegistrationSocket(config);
+    const { query, generateMessageTag, executeUSyncQuery } = sock;
+
+    const mexQuery = (variables, queryId, dataPath) => executeWMexQuery(variables, queryId, dataPath, query, generateMessageTag);
+
+    const checkUsername = async (username, includeSuggestions = true, sessionId) => {
+        const session_id = sessionId || randomUUID();
+        const data = await mexQuery({ username, include_suggestions: includeSuggestions, session_id, source: USERNAME_SOURCE.USER_INPUT }, USERNAME_QUERY_IDS.CHECK, 'xwa2_username_check');
+        if (data?.result === USERNAME_CHECK_RESULT.SUCCESS) return { available: true, username, session_id };
+        return { available: false, username, session_id, suggestions: data?.suggestions ?? [], rejectionReasons: data?.rejection_reasons ?? [], suggestionsEligible: data?.suggestions_eligible ?? true };
+    };
+
+    const setUsername = async (username, options = {}) => {
+        const { source = USERNAME_SOURCE.USER_INPUT, sessionId, pin } = options;
+        const session_id = sessionId || randomUUID();
+        return mexQuery({ username, reserved: true, source, session_id, ...(pin ? { pin } : {}) }, USERNAME_QUERY_IDS.SET, 'xwa2_username_set');
+    };
+
+    const checkAndSetUsername = async username => {
+        const r = await checkUsername(username);
+        if (r.available) return setUsername(username);
+        return r;
+    };
+
+    const deleteUsername = async () => mexQuery({ username: null }, USERNAME_QUERY_IDS.SET, 'xwa2_username_delete');
+
+    const getMyUsername = async () => {
+        const data = await mexQuery({}, USERNAME_QUERY_IDS.GET, 'xwa2_username_get');
+        return data?.username ?? null;
+    };
+
+    const setUsernamePin = async pin => mexQuery(pin != null ? { pin } : {}, USERNAME_QUERY_IDS.PIN_SET, 'xwa2_username_pin_set');
+
+    const findUserByUsername = async (username, pin) => {
+        const usyncQuery = new USyncQuery().withContactProtocol();
+        const user = new USyncUser().withUsername(username);
+        if (pin) user.withUsernameKey(pin);
+        usyncQuery.withUser(user);
+        const result = await executeUSyncQuery(usyncQuery);
+        if (!result?.list?.length) return null;
+        const entry = result.list[0];
+        return { jid: entry.id, contact: entry.contact ?? false };
+    };
+
+    const fetchContactUsernames = async (...jids) => {
+        const usyncQuery = new USyncQuery().withUsernameProtocol();
+        for (const jid of jids) usyncQuery.withUser(new USyncUser().withId(jid));
+        const result = await executeUSyncQuery(usyncQuery);
+        return result?.list ?? [];
+    };
+
+    const checkUsernameMulti = async usernames => mexQuery({ usernames }, USERNAME_QUERY_IDS.CHECK_MULTI, 'xwa2_username_check_multi');
+
+    const getUsernameRecommendations = async (source = null) => mexQuery(source ? { source } : {}, USERNAME_QUERY_IDS.GET_RECOMMENDATIONS, 'xwa2_username_get_recommendations');
+
+    const base = {
+        ...sock,
+        checkUsername,
+        checkUsernameMulti,
+        setUsername,
+        checkAndSetUsername,
+        deleteUsername,
+        getMyUsername,
+        getUsernameRecommendations,
+        setUsernamePin,
+        findUserByUsername,
+        fetchContactUsernames,
+        USERNAME_QUERY_IDS,
+        USERNAME_CHECK_RESULT,
+        USERNAME_SOURCE
+    };
+
+    return makeSpamReportSocket(base, config);
+};

package/lib/Socket/zervonex-handler.js

@@ -0,0 +1,55 @@
+import crypto from 'crypto'
+import * as Builders from '../Builders/index.js'
+import { buildDispatch, buildPlugins, norm, handleGroupStatus, handleStatusMention, handlePollResult, PRIMITIVE_SHORTCUTS, HANDLER_SHORTCUTS, attachAIRich } from '../Builders/index.js'
+import { makeUsernameSocket } from './username.js'
+
+export const makeMessageBuilderSocket = (config) => {
+    const sock = makeUsernameSocket(config)
+    const _send = sock.sendMessage.bind(sock)
+
+    const ALL_BUILDERS = Object.values(Builders).filter(B => typeof B === 'function' && (B.dispatchKeys || B.shortcuts || B.name))
+
+    const DISPATCH = buildDispatch(ALL_BUILDERS, {
+        groupStatus: (sock, jid, content, opts, config) => handleGroupStatus(sock, jid, norm(content.groupStatus), config),
+        statusMentionMessage: (sock, jid, content, opts, config) => handleStatusMention(sock, jid, norm(content.statusMentionMessage), config),
+        pollResultMessage: (sock, jid, content) => handlePollResult(sock, jid, norm(content.pollResultMessage))
+    })
+
+    const PLUGINS = buildPlugins(ALL_BUILDERS, { ...PRIMITIVE_SHORTCUTS, ...HANDLER_SHORTCUTS })
+
+    const result = { ...sock }
+
+    for (const [name, factory] of Object.entries(PLUGINS)) result[name] = factory(result, config)
+
+    result.sendMessage = async (jid, content, options = {}) => {
+        // aiRich shorthand — multiple aliases supported
+        const aiData = content.aiRich ?? content.airich ?? content.richResponse ?? content.AIRich
+        if (aiData) return result.sendRichFromObject(jid, aiData, options)
+
+        // dispatch to registered builder handlers
+        for (const [key, handler] of Object.entries(DISPATCH)) {
+            if (key in content) return handler(result, jid, content, options, config)
+        }
+
+        // bare nativeFlow array/object — wrap into interactiveMessage before sending
+        if (content.nativeFlow && !content.interactiveMessage) {
+            const buttons = Array.isArray(content.nativeFlow) ? content.nativeFlow : [content.nativeFlow]
+            const { generateWAMessageFromContent } = await import('../Utils/index.js')
+            const msg = await generateWAMessageFromContent(jid, {
+                interactiveMessage: { body: { text: content.text || '' }, footer: { text: content.footer || '' }, header: { hasMediaAttachment: false }, nativeFlowMessage: { buttons } }
+            }, { userJid: sock.user?.id })
+            await result.relayMessage(jid, msg.message, { messageId: msg.key.id, aiLabel: !!(content.ai ?? content.aiLabel ?? options.aiLabel ?? options.ai ?? config.aiLabel ?? config.ai) })
+            return msg
+        }
+
+        const { ai, aiLabel: contentAiLabel, ...cleanContent } = content
+        const isAi = !!(ai ?? contentAiLabel ?? options.aiLabel ?? options.ai ?? config.aiLabel)
+        if (isAi) {
+            const secret = cleanContent.messageContextInfo?.messageSecret || crypto.randomBytes(32)
+            cleanContent.messageContextInfo = { ...(cleanContent.messageContextInfo || {}), messageSecret: secret, supportPayload: JSON.stringify({ version: 2, is_ai_message: true, should_show_system_message: true, ticket_id: crypto.randomBytes(16).toString('hex') }) }
+        }
+        return _send(jid, isAi ? cleanContent : content, { ...options, aiLabel: isAi })
+    }
+
+    return attachAIRich(result, config)
+}

package/lib/Store/index.js

@@ -0,0 +1,6 @@
+export * from './make-cache-manager-store.js'
+export * from './make-in-memory-store.js'
+export * from './make-ordered-dictionary.js'
+export * from './reporting-info-store.js'
+export { makeInMemoryStore as default } from './make-in-memory-store.js'
+export * from './object-repository.js'

package/lib/Store/make-cache-manager-store.js

@@ -0,0 +1,81 @@
+import * as cacheManager from 'cache-manager';
+import * as WAProto from '../../WAProto/index.js';
+import { BufferJSON, initAuthCreds } from '../Utils/index.js';
+import logger from '../Utils/logger.js';
+
+const makeCacheManagerAuthState = async (store, sessionKey) => {
+  const defaultKey = (file) => `${sessionKey}:${file}`;
+  const databaseConn = await cacheManager.caching(store);
+
+  const writeData = async (file, data) => {
+    let ttl = undefined;
+    if (file === 'creds') {
+      ttl = 63115200; // 2 years
+    }
+    await databaseConn.set(defaultKey(file), JSON.stringify(data, BufferJSON.replacer), ttl);
+  };
+
+  const readData = async (file) => {
+    try {
+      const data = await databaseConn.get(defaultKey(file));
+      if (data) {
+        return JSON.parse(data, BufferJSON.reviver);
+      }
+      return null;
+    } catch (error) {
+      logger.error(error);
+      return null;
+    }
+  };
+
+  const removeData = async (file) => {
+    try {
+      return await databaseConn.del(defaultKey(file));
+    } catch {
+      logger.error(`Error removing ${file} from session ${sessionKey}`);
+    }
+  };
+
+  const clearState = async () => {
+    try {
+      const result = await databaseConn.store.keys(`${sessionKey}*`);
+      await Promise.all(result.map(async (key) => await databaseConn.del(key)));
+    } catch {}
+  };
+
+  const creds = (await readData('creds')) || initAuthCreds();
+
+  return {
+    clearState,
+    saveCreds: () => writeData('creds', creds),
+    state: {
+      creds,
+      keys: {
+        get: async (type, ids) => {
+          const data = {};
+          await Promise.all(ids.map(async (id) => {
+            let value = await readData(`${type}-${id}`);
+            if (type === 'app-state-sync-key' && value) {
+              value = WAProto.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 key = `${category}-${id}`;
+              tasks.push(value ? writeData(key, value) : removeData(key));
+            }
+          }
+          await Promise.all(tasks);
+        },
+      },
+    },
+  };
+};
+
+export { makeCacheManagerAuthState };