@kelvdra/baileys 1.0.4 → 1.0.5-rc.2

package/lib/Defaults/index.d.ts

@@ -59,4 +59,4 @@ export declare const DEFAULT_CACHE_TTLS: {
     CALL_OFFER: number;
     USER_DEVICES: number;
 };
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=index.d.ts.map

package/lib/Defaults/index.js

@@ -2,14 +2,15 @@ import { proto } from '../../WAProto/index.js';
 import { makeLibSignalRepository } from '../Signal/libsignal.js';
 import { Browsers } from '../Utils/browser-utils.js';
 import logger from '../Utils/logger.js';
-const version = [2, 3000, 1027934701];
-import PHONENUMBER_MCC from './phonenumber-mcc.json' with { type: 'json' };
-export PHONENUMBER_MCC;
+const version = [2, 3000, 1033105955];
+import PHONENUMBER_MCC_1 from './phonenumber-mcc.json' with { type: 'json' };
+export const PHONENUMBER_MCC = PHONENUMBER_MCC_1;
 export const UNAUTHORIZED_CODES = [401, 403, 419];
 export const DEFAULT_ORIGIN = 'https://web.whatsapp.com';
 export const CALL_VIDEO_PREFIX = 'https://call.whatsapp.com/video/';
 export const CALL_AUDIO_PREFIX = 'https://call.whatsapp.com/voice/';
 export const DEF_CALLBACK_PREFIX = 'CB:';
+export const STATUS_EXPIRY_SECONDS = 24 * 60 * 60;
 export const DEF_TAG_PREFIX = 'TAG:';
 export const PHONE_CONNECTION_CB = 'CB:Pong';
 export const WA_ADV_ACCOUNT_SIG_PREFIX = Buffer.from([6, 0]);
@@ -19,6 +20,7 @@ export const WA_ADV_HOSTED_DEVICE_SIG_PREFIX = Buffer.from([6, 6]);
 export const WA_DEFAULT_EPHEMERAL = 7 * 24 * 60 * 60;
 export const NOISE_MODE = 'Noise_XX_25519_AESGCM_SHA256\0\0\0\0';
 export const DICT_VERSION = 3;
+export const PLACEHOLDER_MAX_AGE_SECONDS = 14 * 24 * 60 * 60;
 export const KEY_BUNDLE_TYPE = Buffer.from([5]);
 export const NOISE_WA_HEADER = Buffer.from([87, 65, 6, DICT_VERSION]); // last is "DICT_VERSION"
 /** from: https://stackoverflow.com/questions/3809401/what-is-a-good-regular-expression-to-match-a-url */
@@ -76,6 +78,8 @@ export const MEDIA_PATH_MAP = {
     document: '/mms/document',
     audio: '/mms/audio',
     sticker: '/mms/image',
+    'sticker-pack': '/mms/sticker',
+    'thumbnail-sticker-pack': '/mms/sticker',
     'thumbnail-link': '/mms/image',
     'product-catalog-image': '/product/image',
     'md-app-state': '',
@@ -91,6 +95,8 @@ export const MEDIA_HKDF_KEY_MAPPING = {
     product: 'Image',
     ptt: 'Audio',
     sticker: 'Image',
+    'sticker-pack': 'Sticker Pack',
+    'thumbnail-sticker-pack': 'Sticker Pack',
     video: 'Video',
     'thumbnail-document': 'Document Thumbnail',
     'thumbnail-image': 'Image Thumbnail',
@@ -115,3 +121,16 @@ export const DEFAULT_CACHE_TTLS = {
     USER_DEVICES: 5 * 60 // 5 minutes
 };
 //# sourceMappingURL=index.js.map
+
+// Added from Baileys v7.0.0-rc10
+export const HISTORY_SYNC_PAUSED_TIMEOUT_MS = 120000;
+
+// Added from Baileys v7.0.0-rc10
+export const TimeMs = {
+    Minute: 60 * 1000,
+    Hour: 60 * 60 * 1000,
+    Day: 24 * 60 * 60 * 1000,
+    Week: 7 * 24 * 60 * 60 * 1000
+};
+//# sourceMappingURL=index.js.map
+

package/lib/Socket/chats.js

@@ -166,26 +166,25 @@ export const makeChatsSocket = (config) => {
         }
     };
     /** update the profile picture for yourself or a group */
-    const updateProfilePicture = async (jid, content) => {
-        let targetJid
-        
+    const updateProfilePicture = async (jid, content, dimensions) => {
+        let targetJid;
         if (!jid) {
-            throw new Boom('Illegal no-jid profile update. Please specify either your ID or the ID of the chat you wish to update')
+            throw new Boom('Illegal no-jid profile update. Please specify either your ID or the ID of the chat you wish to update');
         }
-        
         if (jidNormalizedUser(jid) !== jidNormalizedUser(authState.creds.me.id)) {
-            targetJid = jidNormalizedUser(jid) // in case it is someone other than us
+            targetJid = jidNormalizedUser(jid); // in case it is someone other than us
+        }
+        else {
+            targetJid = undefined;
         }
-        
-        const { img } = await generateProfilePicture(content)
-        
+        const { img } = await generateProfilePicture(content, dimensions);
         await query({
             tag: 'iq',
             attrs: {
-                target: targetJid,
                 to: S_WHATSAPP_NET,
                 type: 'set',
-                xmlns: 'w:profile:picture'
+                xmlns: 'w:profile:picture',
+                ...(targetJid ? { target: targetJid } : {})
             },
             content: [
                 {
@@ -194,8 +193,8 @@ export const makeChatsSocket = (config) => {
                     content: img
                 }
             ]
-        })
-    }
+        });
+    };
     /** remove the profile picture for yourself or a group */
     const removeProfilePicture = async (jid) => {
         let targetJid;

package/lib/Socket/groups.js

@@ -2,10 +2,272 @@ import { proto } from '../../WAProto/index.js';
 import { WAMessageAddressingMode, WAMessageStubType } from '../Types/index.js';
 import { generateMessageIDV2, unixTimestampSeconds } from '../Utils/index.js';
 import { getBinaryNodeChild, getBinaryNodeChildren, getBinaryNodeChildString, isLidUser, isPnUser, jidEncode, jidNormalizedUser } from '../WABinary/index.js';
+import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { makeChatsSocket } from './chats.js';
+const pickFirst = (...values) => values.find(v => typeof v === 'string' && v.length > 0);
+const preferPnJid = (primary, pn) => {
+    const normalizedPrimary = primary ? jidNormalizedUser(primary) : undefined;
+    const normalizedPn = pn ? jidNormalizedUser(pn) : undefined;
+    if (isLidUser(normalizedPrimary) && isPnUser(normalizedPn)) return normalizedPn;
+    return normalizedPrimary;
+};
+const getParticipantUsername = (attrs = {}) => pickFirst(
+    attrs.notify,
+    attrs.name,
+    attrs.short_name,
+    attrs.shortName,
+    attrs.pushname,
+    attrs.verified_name,
+    attrs.verifiedName,
+    attrs.vname
+);
+const getJidUser = (jid) => typeof jid === 'string' ? jid.split('@')[0] : undefined;
+const getContactDisplayName = (contact = {}) => pickFirst(
+    contact.name,
+    contact.notify,
+    contact.verifiedName,
+    contact.verified_name,
+    contact.pushname,
+    contact.shortName,
+    contact.short_name
+);
+const participantNameFallback = (participant = {}) => getJidUser(participant.phoneNumber || participant.jid || participant.id || participant.lid);
+const buildGroupParticipant = (attrs = {}) => {
+    const rawJid = attrs.jid ? jidNormalizedUser(attrs.jid) : undefined;
+    const rawLid = attrs.lid ? jidNormalizedUser(attrs.lid) : undefined;
+    const rawPn = pickFirst(attrs.phone_number, attrs.phoneNumber, attrs.jid_pn, attrs.participant_pn, attrs.pn);
+    const pnJid = rawPn ? jidNormalizedUser(rawPn) : undefined;
+    const id = preferPnJid(rawJid, pnJid) || pnJid || rawJid;
+    const lid = isLidUser(rawJid) ? rawJid : (isLidUser(rawLid) ? rawLid : undefined);
+    const username = getParticipantUsername(attrs);
+    const participant = {
+        id,
+        jid: id,
+        phoneNumber: isPnUser(id) ? id : undefined,
+        lid,
+        username,
+        name: username,
+        notify: attrs.notify,
+        admin: (attrs.type || null)
+    };
+    const fallback = participantNameFallback(participant);
+    return {
+        ...participant,
+        username: username || fallback,
+        name: username || fallback,
+        notify: attrs.notify || username || fallback,
+        displayName: username || fallback
+    };
+};
+const normalizeGroupMetadataJids = (metadata) => ({
+    ...metadata,
+    owner: preferPnJid(metadata.owner, metadata.ownerPn),
+    ownerLid: isLidUser(metadata.owner) ? metadata.owner : undefined,
+    subjectOwner: preferPnJid(metadata.subjectOwner, metadata.subjectOwnerPn),
+    subjectOwnerLid: isLidUser(metadata.subjectOwner) ? metadata.subjectOwner : undefined,
+    descOwner: preferPnJid(metadata.descOwner, metadata.descOwnerPn),
+    descOwnerLid: isLidUser(metadata.descOwner) ? metadata.descOwner : undefined,
+    participants: Array.isArray(metadata.participants)
+        ? metadata.participants.map(p => ({ ...p, id: preferPnJid(p.id, p.phoneNumber) || p.id, jid: preferPnJid(p.jid || p.id, p.phoneNumber) || p.jid || p.id }))
+        : []
+});
 export const makeGroupsSocket = (config) => {
     const sock = makeChatsSocket(config);
-    const { authState, ev, query, upsertMessage } = sock;
+    const { authState, ev, query, upsertMessage, executeUSyncQuery } = sock;
+    const { cachedGroupMetadata } = config;
+    // Cache nama kontak dari history/contact/message event.
+    // Catatan: metadata grup dari WA sering hanya mengirim jid/lid/phone_number,
+    // jadi nama member harus diperkaya dari cache kontak lokal jika tersedia.
+    const contactNameCache = new Map();
+    const putContactName = (contact = {}) => {
+        const ids = [contact.id, contact.jid, contact.phoneNumber, contact.lid]
+            .filter(Boolean)
+            .map(jid => {
+                try { return jidNormalizedUser(jid); } catch { return jid; }
+            });
+        if (!ids.length) return;
+        const displayName = getContactDisplayName(contact);
+        const cached = {
+            ...contact,
+            displayName,
+            username: displayName || contact.username,
+            name: contact.name || displayName,
+            notify: contact.notify || displayName
+        };
+        for (const id of ids) contactNameCache.set(id, cached);
+    };
+    const getCachedContactName = (participant = {}) => {
+        const ids = [participant.id, participant.jid, participant.phoneNumber, participant.lid].filter(Boolean);
+        for (const id of ids) {
+            const normalized = (() => { try { return jidNormalizedUser(id); } catch { return id; } })();
+            const contact = contactNameCache.get(normalized);
+            const name = getContactDisplayName(contact);
+            if (name) return name;
+        }
+        return undefined;
+    };
+    const enrichGroupMetadataNames = (metadata = {}) => ({
+        ...metadata,
+        participants: Array.isArray(metadata.participants)
+            ? metadata.participants.map(participant => {
+                const cachedName = getCachedContactName(participant);
+                const displayName = pickFirst(participant.username, participant.name, participant.notify, cachedName, participantNameFallback(participant));
+                return {
+                    ...participant,
+                    username: displayName,
+                    name: displayName,
+                    notify: pickFirst(participant.notify, displayName),
+                    displayName
+                };
+            })
+            : []
+    });
+    ev.on('contacts.upsert', contacts => contacts?.forEach?.(putContactName));
+    ev.on('contacts.update', contacts => contacts?.forEach?.(putContactName));
+    ev.on('messaging-history.set', ({ contacts }) => contacts?.forEach?.(putContactName));
+    ev.on('messages.upsert', ({ messages }) => {
+        for (const msg of messages || []) {
+            const remoteJid = msg?.key?.remoteJid;
+            const participant = msg?.key?.participant;
+            const id = participant || (remoteJid && !remoteJid.endsWith('@g.us') ? remoteJid : undefined);
+            if (id && msg?.pushName) putContactName({ id, notify: msg.pushName });
+        }
+    });
+    // ── Built-in group metadata cache ─────────────────────────────────────────
+
+    const fetchParticipantUsernames = async (participants = []) => {
+        // WA username (@username) beda dengan pushName/kontak.
+        // groupMetadata biasanya tidak membawa username, jadi kita query USync username.
+        // Jika akun belum punya username atau server tidak mengizinkan, hasilnya kosong.
+        const entries = participants
+            .map(p => ({ participant: p, jid: p.jid || p.id || p.phoneNumber || p.lid }))
+            .filter(({ jid }) => typeof jid === 'string' && jid.length > 0);
+        const result = new Map();
+        const chunkSize = config.groupUsernameQueryChunkSize || 50;
+        for (let i = 0; i < entries.length; i += chunkSize) {
+            const chunk = entries.slice(i, i + chunkSize);
+            try {
+                const usync = new USyncQuery().withContext('interactive').withUsernameProtocol();
+                for (const { jid } of chunk) {
+                    const normalized = (() => { try { return jidNormalizedUser(jid); } catch { return jid; } })();
+                    usync.withUser(new USyncUser().withId(normalized));
+                }
+                const res = await executeUSyncQuery(usync);
+                for (const item of res?.list || []) {
+                    const username = typeof item.username === 'string' && item.username.length > 0 ? item.username : undefined;
+                    if (username) result.set(jidNormalizedUser(item.id), username);
+                }
+            } catch (err) {
+                config.logger?.debug?.({ err }, 'failed to fetch group participant usernames');
+            }
+        }
+        return result;
+    };
+    const enrichGroupMetadataUsernames = async (metadata = {}) => {
+        const normalized = normalizeGroupMetadataJids(metadata);
+        const shouldQueryUsername = config.fetchGroupParticipantsUsername !== false;
+        const usernameMap = shouldQueryUsername ? await fetchParticipantUsernames(normalized.participants) : new Map();
+        const withNames = enrichGroupMetadataNames(normalized);
+        return {
+            ...withNames,
+            participants: withNames.participants.map(participant => {
+                const keys = [participant.jid, participant.id, participant.phoneNumber, participant.lid].filter(Boolean);
+                let waUsername;
+                for (const key of keys) {
+                    const normalizedKey = (() => { try { return jidNormalizedUser(key); } catch { return key; } })();
+                    waUsername = usernameMap.get(normalizedKey);
+                    if (waUsername) break;
+                }
+                return waUsername
+                    ? {
+                        ...participant,
+                        username: waUsername,
+                        waUsername,
+                        displayName: waUsername,
+                        name: participant.name,
+                        notify: participant.notify
+                    }
+                    : participant;
+            })
+        };
+    };
+    const groupMetadataCache = new Map();
+    const GROUP_CACHE_TTL = (config.groupCacheTTL || 5) * 60 * 1000; // default 5 menit
+    const getCachedGroupMetadata = async (jid) => {
+        // 1. Cek user-provided cachedGroupMetadata (dari config makeWASocket)
+        if (cachedGroupMetadata) {
+            const cached = await cachedGroupMetadata(jid);
+            if (cached && Array.isArray(cached.participants)) return cached;
+        }
+        // 2. Cek internal Map cache
+        const entry = groupMetadataCache.get(jid);
+        if (entry && Date.now() - entry.ts < GROUP_CACHE_TTL) {
+            return entry.data;
+        }
+        return undefined;
+    };
+    const setCachedGroupMetadata = (jid, data) => {
+        groupMetadataCache.set(jid, { data, ts: Date.now() });
+    };
+    // Update cache saat groups.update event
+    ev.on('groups.update', (updates) => {
+        for (const update of updates) {
+            const entry = groupMetadataCache.get(update.id);
+            if (entry) {
+                // Merge update ke cache yang ada
+                groupMetadataCache.set(update.id, {
+                    data: { ...entry.data, ...update },
+                    ts: entry.ts
+                });
+            }
+        }
+    });
+    // Update cache saat participant berubah
+    // Debounce map to prevent duplicate refresh calls for same group
+    const _refreshDebounce = new Map();
+    const _refreshGroupMetadata = async (jid) => {
+        // Debounce: skip jika refresh sudah dijadwalkan dalam 2 detik terakhir
+        if (_refreshDebounce.has(jid)) return;
+        _refreshDebounce.set(jid, true);
+        setTimeout(() => _refreshDebounce.delete(jid), 2000);
+        try {
+            const result = await groupQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }]);
+            const meta = extractGroupMetadata(result);
+            setCachedGroupMetadata(jid, meta);
+            // Emit groups.update agar subscriber luar (makeInMemoryStore dll) ikut terupdate
+            ev.emit('groups.update', [meta]);
+        } catch (e) {
+            // Ignore jika gagal (bot mungkin sudah keluar dari grup)
+        }
+    };
+    ev.on('group-participants.update', ({ id, participants, action }) => {
+        const entry = groupMetadataCache.get(id);
+        if (entry && Array.isArray(entry.data?.participants)) {
+            // Fast-path: update cache lokal secara optimistis tanpa tunggu network
+            const meta = { ...entry.data, participants: [...entry.data.participants] };
+            if (action === 'add') {
+                const existing = new Set(meta.participants.map(p => p.id));
+                for (const jid of participants) {
+                    if (!existing.has(jid)) meta.participants.push({ id: jid, admin: null });
+                }
+            } else if (action === 'remove') {
+                meta.participants = meta.participants.filter(p => !participants.includes(p.id));
+            } else if (action === 'promote') {
+                meta.participants = meta.participants.map(p =>
+                    participants.includes(p.id) ? { ...p, admin: 'admin' } : p
+                );
+            } else if (action === 'demote') {
+                meta.participants = meta.participants.map(p =>
+                    participants.includes(p.id) ? { ...p, admin: null } : p
+                );
+            }
+            groupMetadataCache.set(id, { data: meta, ts: entry.ts });
+        }
+        // Auto-refresh dari network untuk semua aksi participant
+        // Ini memastikan data selalu akurat dari server WA
+        _refreshGroupMetadata(id);
+    });
+    // ── End group metadata cache ───────────────────────────────────────────────
     const groupQuery = async (jid, type, content) => query({
         tag: 'iq',
         attrs: {
@@ -16,8 +278,15 @@ export const makeGroupsSocket = (config) => {
         content
     });
     const groupMetadata = async (jid) => {
+        // Cek cache dulu sebelum hit network
+        const cached = await getCachedGroupMetadata(jid);
+        if (cached) return await enrichGroupMetadataUsernames(cached);
+        // Fetch dari WA
         const result = await groupQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }]);
-        return extractGroupMetadata(result);
+        const meta = extractGroupMetadata(result);
+        // Simpan ke cache
+        setCachedGroupMetadata(jid, meta);
+        return await enrichGroupMetadataUsernames(meta);
     };
     const groupFetchAllParticipating = async () => {
         const result = await query({
@@ -48,9 +317,10 @@ export const makeGroupsSocket = (config) => {
                     attrs: {},
                     content: [groupNode]
                 });
-                data[meta.id] = meta;
+                data[meta.id] = enrichGroupMetadataNames(normalizeGroupMetadataJids(meta));
             }
         }
+        // TODO: properly parse LID / PN DATA
         sock.ev.emit('groups.update', Object.values(data));
         return data;
     };
@@ -80,7 +350,7 @@ export const makeGroupsSocket = (config) => {
                     }))
                 }
             ]);
-            return extractGroupMetadata(result);
+            return enrichGroupMetadataNames(extractGroupMetadata(result));
         },
         groupLeave: async (id) => {
             await groupQuery('@g.us', 'set', [
@@ -237,7 +507,7 @@ export const makeGroupsSocket = (config) => {
                     participant: key.remoteJid
                 },
                 messageStubType: WAMessageStubType.GROUP_PARTICIPANT_ADD,
-                messageStubParameters: [authState.creds.me.id],
+                messageStubParameters: [JSON.stringify(authState.creds.me)],
                 participant: key.remoteJid,
                 messageTimestamp: unixTimestampSeconds()
             }, 'notify');
@@ -264,7 +534,47 @@ export const makeGroupsSocket = (config) => {
                 { tag: 'membership_approval_mode', attrs: {}, content: [{ tag: 'group_join', attrs: { state: mode } }] }
             ]);
         },
-        groupFetchAllParticipating
+        groupFetchAllParticipating,
+        /**
+         * Auto detect isAdmin & isBotAdmin dari groupMetadata
+         * @param {string} groupJid - JID grup
+         * @param {string} senderJid - JID pengirim pesan
+         * @returns {Promise<{isAdmin: boolean, isBotAdmin: boolean}>}
+         */
+        getAdminStatus: async (groupJid, senderJid) => {
+            const normalizeJid = (jid) => {
+                if (!jid) return null;
+                try {
+                    return jidNormalizedUser(jid).split('@')[0];
+                } catch {
+                    return String(jid).split('@')[0];
+                }
+            };
+            const botJid = sock.authState?.creds?.me?.id;
+            const meta = await sock.groupMetadata(groupJid).catch(() => null);
+            if (!meta || !Array.isArray(meta.participants)) {
+                return { isAdmin: false, isBotAdmin: false };
+            }
+            const senderNorm = normalizeJid(senderJid);
+            const botNorm = normalizeJid(botJid);
+            const isAdmin = meta.participants.some(p => {
+                const pid = normalizeJid(p.jid || p.id || p.lid);
+                return pid === senderNorm && (p.admin === 'admin' || p.admin === 'superadmin');
+            });
+            // Cek isBotAdmin: via participants
+            let isBotAdmin = meta.participants.some(p => {
+                const pid = normalizeJid(p.jid || p.id || p.lid);
+                return pid === botNorm && (p.admin === 'admin' || p.admin === 'superadmin');
+            });
+            // Fallback: cek via owner/subjectOwner
+            if (!isBotAdmin) {
+                const owners = [meta.owner, meta.subjectOwner, meta.ownerPn]
+                    .filter(Boolean)
+                    .map(normalizeJid);
+                if (owners.includes(botNorm)) isBotAdmin = true;
+            }
+            return { isAdmin, isBotAdmin };
+        }
     };
 };
 export const extractGroupMetadata = (result) => {
@@ -290,8 +600,9 @@ export const extractGroupMetadata = (result) => {
         notify: group.attrs.notify,
         addressingMode: group.attrs.addressing_mode === 'lid' ? WAMessageAddressingMode.LID : WAMessageAddressingMode.PN,
         subject: group.attrs.subject,
-        subjectOwner: group.attrs.s_o,
-        subjectOwnerPn: group.attrs.s_o_pn,
+        subjectOwner: preferPnJid(group.attrs.s_o, group.attrs.s_o_pn),
+        subjectOwnerPn: group.attrs.s_o_pn ? jidNormalizedUser(group.attrs.s_o_pn) : undefined,
+        subjectOwnerLid: isLidUser(group.attrs.s_o) ? jidNormalizedUser(group.attrs.s_o) : undefined,
         subjectTime: +group.attrs.s_t,
         size: group.attrs.size ? +group.attrs.size : getBinaryNodeChildren(group, 'participant').length,
         creation: +group.attrs.creation,
@@ -310,17 +621,9 @@ export const extractGroupMetadata = (result) => {
         isCommunityAnnounce: !!getBinaryNodeChild(group, 'default_sub_group'),
         joinApprovalMode: !!getBinaryNodeChild(group, 'membership_approval_mode'),
         memberAddMode,
-        participants: getBinaryNodeChildren(group, 'participant').map(({ attrs }) => {
-            // TODO: Store LID MAPPINGS
-            return {
-                id: attrs.jid,
-                phoneNumber: isLidUser(attrs.jid) && isPnUser(attrs.phone_number) ? attrs.phone_number : undefined,
-                lid: isPnUser(attrs.jid) && isLidUser(attrs.lid) ? attrs.lid : undefined,
-                admin: (attrs.type || null)
-            };
-        }),
+        participants: getBinaryNodeChildren(group, 'participant').map(({ attrs }) => buildGroupParticipant(attrs)),
         ephemeralDuration: eph ? +eph : undefined
     };
-    return metadata;
+    return normalizeGroupMetadataJids(metadata);
 };
 //# sourceMappingURL=groups.js.map