@kelvdra/baileys 1.0.4 → 1.0.5

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

@@ -6,6 +6,85 @@ import { makeChatsSocket } from './chats.js';
 export const makeGroupsSocket = (config) => {
     const sock = makeChatsSocket(config);
     const { authState, ev, query, upsertMessage } = sock;
+    const { cachedGroupMetadata } = config;
+    // ── Built-in group metadata cache ─────────────────────────────────────────
+    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 +95,15 @@ export const makeGroupsSocket = (config) => {
         content
     });
     const groupMetadata = async (jid) => {
+        // Cek cache dulu sebelum hit network
+        const cached = await getCachedGroupMetadata(jid);
+        if (cached) return 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 meta;
     };
     const groupFetchAllParticipating = async () => {
         const result = await query({
@@ -51,6 +137,7 @@ export const makeGroupsSocket = (config) => {
                 data[meta.id] = meta;
             }
         }
+        // TODO: properly parse LID / PN DATA
         sock.ev.emit('groups.update', Object.values(data));
         return data;
     };
@@ -237,7 +324,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 +351,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) => {
@@ -311,11 +438,17 @@ export const extractGroupMetadata = (result) => {
         joinApprovalMode: !!getBinaryNodeChild(group, 'membership_approval_mode'),
         memberAddMode,
         participants: getBinaryNodeChildren(group, 'participant').map(({ attrs }) => {
-            // TODO: Store LID MAPPINGS
+            const isLid = isLidUser(attrs.jid);
+            const pn = attrs.phone_number;
+            const hasPn = isPnUser(pn);
+            // Jika grup pakai LID addressing:
+            // - id   → pakai phoneNumber (PN) agar bisa dicompare dengan m.sender
+            // - lid  → simpan LID asli
+            // Jika grup pakai PN addressing: id tetap PN
             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,
+                id: isLid && hasPn ? pn : attrs.jid,
+                phoneNumber: isLid && hasPn ? pn : undefined,
+                lid: isLid ? attrs.jid : (isPnUser(attrs.jid) && isLidUser(attrs.lid) ? attrs.lid : undefined),
                 admin: (attrs.type || null)
             };
         }),

package/lib/Socket/hydra.js

@@ -22,6 +22,7 @@ class hydra {
         if (content.orderMessage) return 'ORDER';
         if (content.groupStatus) return 'GROUP_STATUS';
         if (content.carouselMessage || content.carousel) return 'CAROUSEL'; 
+        if (content.stickerPack) return "STICKER_PACK";
         return null;
 }
     
@@ -127,6 +128,49 @@ class hydra {
     return msg;
 }
 
+    async handleStickerPack(stickerPack, jid, quoted) {
+        const result = await this.utils.prepareStickerPackMessage(stickerPack, {
+            logger: this.utils?.logger,
+            upload: this.waUploadToServer,
+            options: this.utils?.options || {},
+            mediaUploadTimeoutMs: this.utils?.mediaUploadTimeoutMs
+        });
+
+        if (result.isBatched) {
+            let lastMsg;
+            for (let i = 0; i < result.stickerPackMessage.length; i++) {
+                const msg = await this.utils.generateWAMessageFromContent(
+                    jid,
+                    { stickerPackMessage: result.stickerPackMessage[i] },
+                    { quoted, upload: this.waUploadToServer }
+                );
+
+                await this.relayMessage(jid, msg.message, {
+                    messageId: msg.key.id
+                });
+
+                lastMsg = msg;
+
+                if (i < result.stickerPackMessage.length - 1) {
+                    await new Promise(r => setTimeout(r, 2000));
+                }
+            }
+            return lastMsg;
+        }
+
+        const msg = await this.utils.generateWAMessageFromContent(
+            jid,
+            { stickerPackMessage: result.stickerPackMessage },
+            { quoted, upload: this.waUploadToServer }
+        );
+
+        await this.relayMessage(jid, msg.message, {
+            messageId: msg.key.id
+        });
+
+        return msg;
+    }
+
     async handlePayment(content, quoted) {
         const data = content.requestPaymentMessage;
         let notes = {};