@alannxd/baileys 6.2.7 → 6.2.8

package/lib/Defaults/index.js

@@ -2,7 +2,7 @@ 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, 1043857760];
+const version = [2, 3000, 1035194821];
 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/';
@@ -51,7 +51,7 @@ export const DEFAULT_CONNECTION_CONFIG = {
     waWebSocketUrl: 'wss://web.whatsapp.com/ws/chat',
     connectTimeoutMs: 20000,
     keepAliveIntervalMs: 30000,
-    logger: logger.child({ class: 'baileys' }),
+    logger: logger.child({ class: 'poucode' }),
     emitOwnEvents: true,
     defaultQueryTimeoutMs: 60000,
     customUploadHosts: [],

package/lib/Socket/Client/websocket.js

@@ -22,14 +22,44 @@ export class WebSocketClient extends AbstractSocketClient {
         if (this.socket) {
             return;
         }
+        
+        const headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+            'Accept-Language': 'en-US,en;q=0.9',
+            'Accept-Encoding': 'gzip, deflate, br',
+            'Accept': '*/*',
+            'DNT': '1',
+            'Pragma': 'no-cache',
+            'Cache-Control': 'no-cache',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-origin',
+            'Sec-GPC': '1',
+            ...this.config.options?.headers
+        };
+
         this.socket = new WebSocket(this.url, {
             origin: DEFAULT_ORIGIN,
-            headers: this.config.options?.headers,
-            handshakeTimeout: this.config.connectTimeoutMs,
-            timeout: this.config.connectTimeoutMs,
-            agent: this.config.agent
+            headers: headers,
+            handshakeTimeout: this.config.connectTimeoutMs || 30000,
+            timeout: this.config.connectTimeoutMs || 30000,
+            agent: this.config.agent,
+            perMessageDeflate: false,
+            maxPayload: 100 * 1024 * 1024,
+            rejectUnauthorized: false,
+            keepalive: true,
+            keepaliveInterval: 25000
         });
+        
         this.socket.setMaxListeners(0);
+        
+        this.socket.on('error', (error) => {
+            const errorCode = error?.code;
+            if (errorCode === 'ECONNREFUSED' || errorCode === 'ENOTFOUND') {
+                console.warn('WebSocket connection refused, retrying...');
+            }
+        });
+        
         const events = ['close', 'error', 'upgrade', 'message', 'open', 'ping', 'pong', 'unexpected-response'];
         for (const event of events) {
             this.socket?.on(event, (...args) => this.emit(event, ...args));
@@ -51,4 +81,4 @@ export class WebSocketClient extends AbstractSocketClient {
         return Boolean(this.socket);
     }
 }
-//# sourceMappingURL=websocket.js.map
+//# sourceMappingURL=websocket.js.map

package/lib/Socket/chats.js

@@ -397,11 +397,6 @@ export const makeChatsSocket = (config) => {
         return {
             onMutation(mutation) {
                 processSyncAction(mutation, ev, authState.creds.me, isInitialSync ? { accountSettings: authState.creds.accountSettings } : undefined, logger);
-                const nctSalt = mutation?.syncAction?.value?.nctSaltSyncAction?.salt;
-                if (nctSalt?.length) {
-                    authState.keys.set({ 'nct-salt': { default: Buffer.from(nctSalt) } })
-                        .catch(err => logger?.debug({ err: err?.message }, 'failed to store nct salt'));
-                }
             }
         };
     };

package/lib/Socket/index.js

@@ -1,20 +1,12 @@
 import { DEFAULT_CONNECTION_CONFIG } from '../Defaults/index.js';
 import { makeCommunitiesSocket } from './communities.js';
-import { makeInteropSocket } from './interop.js'
-import { makePrivacySocket } from './privacy.js'
-import { makeGraphQLSocket } from './graphql.js'
-import { makeMessageBuilderSocket } from './message-builder.js'
 // export the last socket layer
 const makeWASocket = (config) => {
     const newConfig = {
         ...DEFAULT_CONNECTION_CONFIG,
         ...config
     };
-    const satu = makeCommunitiesSocket(newConfig);
-    const dua = makeInteropSocket(satu);
-    const tiga = makePrivacySocket(dua);
-    const empat = makeGraphQLSocket(tiga);
-    return makeMessageBuilderSocket(empat);
+    return makeCommunitiesSocket(newConfig);
 };
 export default makeWASocket;
 //# sourceMappingURL=index.js.map

package/lib/Socket/luxu.js

@@ -177,7 +177,6 @@ export default class imup {
                 newsletterJid: "0@newsletter",
                 serverMessageId: 1,
                 newsletterName: `WhatsApp`,
-                contentType: 1,
                 timestamp: new Date().toISOString(),
                 senderName: "AlannXD",
                 contentType: "UPDATE_CARD",
@@ -306,7 +305,7 @@ export default class imup {
 
         const Haha = await this.utils.generateWAMessageFromContent(jid, {
             orderMessage: {
-                orderId: "ALANNXD25022008",
+                orderId: orderData.orderId || ("ALANNXD" + Date.now()),
                 thumbnail: orderData.thumbnail || null,
                 itemCount: orderData.itemCount || 0,
                 status: "ACCEPTED",
@@ -314,7 +313,7 @@ export default class imup {
                 message: orderData.message,
                 orderTitle: orderData.orderTitle,
                 sellerJid: "0@whatsapp.net",
-                token: "ALANNXD_EXAMPLE_TOKEN",
+                token: orderData.token || "ALANNXD_EXAMPLE_TOKEN",
                 totalAmount1000: orderData.totalAmount1000 || 0,
                 totalCurrencyCode: orderData.totalCurrencyCode || "IDR",
                 messageVersion: 2
@@ -362,7 +361,7 @@ export default class imup {
             throw new Error('group required!')
         }
 
-        const msg = this.utils.generateWAMessageFromContent(jid, {
+        const msg = await this.utils.generateWAMessageFromContent(jid, {
             protocolMessage: {
                 type: "GROUP_MEMBER_LABEL_CHANGE",
                 memberLabel: {
@@ -384,4 +383,4 @@ export default class imup {
             ]
         })
     }
-}
+}

package/lib/Socket/messages-recv.js

@@ -1280,7 +1280,7 @@ export const makeMessagesRecvSocket = (config) => {
                     msgRelayOpts.useUserDevicesCache = false;
                 }
                 else {
-                    msgRelayOpts.participants = {
+                    msgRelayOpts.participant = {
                         jid: participant,
                         count: +retryNode.attrs.count
                     };

package/lib/Socket/messages-send.js

@@ -12,7 +12,7 @@ import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { makeUsernameSocket } from './username.js';
 import imup from './luxu.js';
 import * as Utils_1 from '../Utils/index.js';
-import { randomBytes, createHmac } from 'crypto';
+import { randomBytes } from 'crypto';
 export const makeMessagesSocket = (config) => {
     const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: httpRequestOptions, patchMessageBeforeSending, cachedGroupMetadata, enableRecentMessageCache, maxMsgRetryCount, aiLabel } = config;
     const sock = makeUsernameSocket(config);
@@ -433,22 +433,18 @@ export const makeMessagesSocket = (config) => {
 	    message,
 	    {
 		    messageId: msgId,
-        	participant,
-        	participants: retryParticipants,
-        	isSecret,
-        	protected: protectedSend,
+        	participant = false,
+		    Alanself = false,
 		    additionalAttributes,
 		    additionalNodes,
 	    	useUserDevicesCache,
 		    useCachedGroupMetadata,
-		    statusJidList,
-		    cstoken = true
+		    statusJidList
 	    }
 	) => {
 	    const meId = authState.creds.me.id
     	const meLid = authState.creds.me?.lid
-	    const isRetryResend = Boolean(retryParticipants?.jid && retryParticipants?.count != null)
-	    const isRecipientOnly = Boolean(participant?.jid)
+	    const isRetryResend = Boolean(participant?.jid)
 	    let shouldIncludeDeviceIdentity = isRetryResend
 	    const statusJid = 'status@broadcast'
 	    const { user, server } = jidDecode(jid)
@@ -473,16 +469,6 @@ export const makeMessagesSocket = (config) => {
 	    	messageContextInfo: message.messageContextInfo
 	    }
 	    const extraAttrs = {}
-    	if (isRetryResend) {
-    		if (!isGroup &&!isStatus) {
-    			additionalAttributes = { ...additionalAttributes, device_fanout: 'false' }
-    		}
-    		const { user: retryUser, device: retryDevice } = jidDecode(retryParticipants.jid)
-    		devices.push({ user: retryUser, device: retryDevice, jid: retryParticipants.jid })
-    	}
-    	if ((isRecipientOnly || isSecret || protectedSend) &&!isGroup &&!isStatus) {
-    		additionalAttributes = { ...additionalAttributes, device_fanout: 'false' }
-    	}
     	const regexGroupOld = /^(\d{1,15})-(\d+)@g\.us$/
 	    const messages = normalizeMessageContent(message)
 	    const buttonType = getButtonType(messages)
@@ -524,7 +510,7 @@ export const makeMessagesSocket = (config) => {
 			    		return groupData
 			    	})(),
 		    		(async () => {
-		    			if (!retryParticipants &&!isStatus) {
+		    			if (!participant &&!isStatus) {
 			    			const result = await authState.keys.get('sender-key-memory', [jid])
 				    		return result[jid] || {}
 			    		}
@@ -664,7 +650,7 @@ export const makeMessagesSocket = (config) => {
 			    for (const device of devices) {
 		    		const deviceJid = device.jid
 		    		const hasKey =!!senderKeyMap[deviceJid]
-		    		if (!hasKey ||!!retryParticipants &&!isHostedLidUser(deviceJid) &&!isHostedPnUser(deviceJid) && device.device!== 99) {
+		    		if (!hasKey ||!!participant &&!isHostedLidUser(deviceJid) &&!isHostedPnUser(deviceJid) && device.device!== 99) {
 			    		senderKeyRecipients.push(deviceJid)
 		    			senderKeyMap[deviceJid] = true
 		    		}
@@ -693,7 +679,7 @@ export const makeMessagesSocket = (config) => {
 		    		logger.debug({ to: jid, ownId }, 'Using PN identity for @s.whatsapp.net conversation')
 	    		}
 	    		const { user: ownUser } = jidDecode(ownId)
-		    	if (!isRetryResend) {
+		    	if (!participant) {
 	    			const patchedForReporting = await patchMessageBeforeSending(message, [jid])
 		    		reportingMessage = Array.isArray(patchedForReporting)
 		    			? patchedForReporting.find(item => item.recipientJid === jid) || patchedForReporting[0]
@@ -723,33 +709,38 @@ export const makeMessagesSocket = (config) => {
 	    		const { user: mePnUser } = jidDecode(meId)
 	    		const { user: meLidUser } = meLid? jidDecode(meLid) : { user: null }
 	    		for (const { user, jid } of devices) {
-	    		    /** participant method by Xzc || Tsm, who's delete the credits = love BBC */
+	    		    /** Alanself: opsi untuk skip sync pesan ke device lain milik akun sendiri (private chat) */
                     const isExactSenderDevice = jid === meId || (meLid && jid === meLid)
                     if (isExactSenderDevice) {
                         logger.debug({ jid, meId, meLid }, 'Skipping exact sender device (whatsmeow pattern)')
                         continue
                     }
                     const isMe = user === mePnUser || user === meLidUser
-                    const hasDevice = jid.includes(':')
                     let ptcp = false
-                    if (retryParticipants) {
+                    if (Alanself) {
                         if (!isJidGroup(jid) && !isStatus) {
                             if (!(!isMe)) ptcp = true
                         } else {
                             ptcp = false
                         }
                     }
-                    if (ptcp) continue
-                    if (isRecipientOnly && isMe) continue
-                    if (isSecret && !(!isMe && !hasDevice)) continue
-                    if (protectedSend && !isMe && hasDevice) continue
-                    if (isMe) {
-                        meRecipients.push(jid)
-                    } else {
-                        otherRecipients.push(jid)
+                    if (!ptcp) {
+                        if (isMe) {
+                            meRecipients.push(jid)
+                        } else {
+                            otherRecipients.push(jid)
+                        }
+                        allRecipients.push(jid)
                     }
-                    allRecipients.push(jid)
                 }
+	    		// Fix: detect silent delivery failure — if the destination is genuinely
+	    		// someone else (not our own number) and device resolution produced zero
+	    		// recipient devices for them, don't proceed as if the send succeeded.
+	    		const isSelfChatDestination = user === mePnUser || user === meLidUser
+	    		if (!isRetryResend && !isSelfChatDestination && otherRecipients.length === 0) {
+	    			logger.warn({ jid, deviceCount: devices.length, Alanself }, 'relayMessage: no recipient devices resolved for the other party; aborting to avoid a silent no-op send')
+	    			throw new Boom('No devices resolved for recipient — message was not delivered to the other party', { statusCode: 421, data: { jid } })
+	    		}
 	    		await assertSessions(allRecipients)
 		    	const [
 		    		{ nodes: meNodes, shouldIncludeDeviceIdentity: s1 },
@@ -765,38 +756,18 @@ export const makeMessagesSocket = (config) => {
 	    		shouldIncludeDeviceIdentity = shouldIncludeDeviceIdentity || s1 || s2
     	}
 	  	if (isRetryResend) {
-	   		const isParticipantLid = isLidUser(retryParticipants.jid)
-	    	const isMe = areJidsSameUser(retryParticipants.jid, isParticipantLid? meLid : meId)
-	   		let messageToSend = message
-	   		if (isGroupOrStatus) {
-	   			let groupSenderIdentity
-	   			try {
-	   				if (meLid && await signalRepository.hasSenderKey({ group: destinationJid, meId: meLid })) {
-	   					groupSenderIdentity = meLid
-	   				} else if (await signalRepository.hasSenderKey({ group: destinationJid, meId })) {
-	   					groupSenderIdentity = meId
-	   				}
-	   				if (groupSenderIdentity) {
-	   					const skdm = await signalRepository.getSenderKeyDistributionMessage({ group: destinationJid, meId: groupSenderIdentity })
-	   					messageToSend = {
-	   						...message,
-	   						senderKeyDistributionMessage: { groupId: destinationJid, axolotlSenderKeyDistributionMessage: skdm }
-	   					}
-	   				}
-	   			} catch (err) {
-	   				logger.warn({ err, jid: destinationJid }, 'failed to build SKDM for retry, sending without it')
-	   			}
-	   		}
+	   		const isParticipantLid = jidDecode(participant.jid).server === 'lid'
+	    	const isMe = areJidsSameUser(participant.jid, isParticipantLid? meLid : meId)
 	   		const encodedMessageToSend = isMe
-		   		? encodeWAMessage({ deviceSentMessage: { destinationJid, message: messageToSend } })
-		   		: encodeWAMessage(messageToSend)
+		   		? encodeWAMessage({ deviceSentMessage: { destinationJid, message } })
+		   		: encodeWAMessage(message)
 	    	const { type, ciphertext: encryptedContent } = await signalRepository.encryptMessage({
 		    	data: encodedMessageToSend,
-	    		jid: retryParticipants.jid
+	    		jid: participant.jid
 		   	})
 		   	binaryNodeContent.push({
 		   		tag: 'enc',
-		   		attrs: { v: '2', type, count: (retryParticipants.count?? 0).toString() },
+		   		attrs: { v: '2', type, count: (participant.count?? 0).toString() },
 	    		content: encryptedContent
 	    	})
        	}
@@ -816,17 +787,6 @@ export const makeMessagesSocket = (config) => {
 			tag: 'message',
 			attrs: { id: msgId, to: destinationJid, type: getMessageType(message),...(additionalAttributes || {}) },
 			content: binaryNodeContent
-    	}
-		if (isRetryResend) {
-			if (isJidGroup(destinationJid)) {
-				stanza.attrs.to = destinationJid
-				stanza.attrs.participant = retryParticipants.jid
-			} else if (areJidsSameUser(retryParticipants.jid, meId)) {
-				stanza.attrs.to = retryParticipants.jid
-				stanza.attrs.recipient = destinationJid
-			} else {
-				stanza.attrs.to = retryParticipants.jid
-			}
     	}
 		if (shouldIncludeDeviceIdentity) {
 			stanza.content.push({ tag: 'device-identity', attrs: {}, content: encodeSignedDeviceIdentity(authState.creds.account, true) })
@@ -849,7 +809,7 @@ export const makeMessagesSocket = (config) => {
 		if (!isNewsletter &&!isRetryResend && reportingMessage?.messageContextInfo?.messageSecret && shouldIncludeReportingToken(reportingMessage)) {
 			try {
 				const encoded = encodeWAMessage(reportingMessage)
-				const reportingKey = { id: msgId, fromMe: true, remoteJid: destinationJid, participant: retryParticipants?.jid }
+				const reportingKey = { id: msgId, fromMe: true, remoteJid: destinationJid, participant: participant?.jid }
 				const reportingNode = await getMessageReportingToken(encoded, reportingMessage, reportingKey)
 				if (reportingNode) {
 					stanza.content.push(reportingNode)
@@ -895,26 +855,6 @@ export const makeMessagesSocket = (config) => {
 	    }
 		if (tcTokenBuffer?.length && sock.serverProps.privacyTokenOn1to1) {
 			stanza.content.push({ tag: 'tctoken', attrs: {}, content: tcTokenBuffer })
-    	}
-		if (cstoken && is1on1Send &&!tcTokenBuffer?.length) {
-			try {
-				const lidJid = await resolveTcTokenJid(destinationJid, getLIDForPN)
-				if (isLidUser(lidJid)) {
-					const saltRes = await authState.keys.get('nct-salt', ['default'])
-					const nctSalt = saltRes?.default
-					if (nctSalt?.length) {
-						const cs = createHmac('sha256', Buffer.from(nctSalt)).update(Buffer.from(lidJid, 'utf8')).digest()
-						stanza.content.push({ tag: 'cstoken', attrs: {}, content: cs })
-						logger.debug({ jid: destinationJid, lid: lidJid }, 'attached cstoken (nct fallback)')
-					} else {
-						logger.debug({ jid: destinationJid }, 'cstoken requested but no nct salt stored yet')
-					}
-				} else {
-					logger.debug({ jid: destinationJid }, 'cstoken requested but recipient has no LID')
-				}
-			} catch (err) {
-				logger.debug({ jid: destinationJid, err: err?.message }, 'cstoken attach failed')
-			}
     	}
 		if (additionalNodes && additionalNodes.length > 0 &&!didPushAdditional) {
 			stanza.content.push(...additionalNodes)
@@ -947,7 +887,7 @@ export const makeMessagesSocket = (config) => {
 				.catch(err => logger.debug({ jid: destinationJid, err: err?.message }, 'fire-and-forget tctoken issuance failed'))
 				.finally(() => inFlightTcTokenIssuance.delete(tcTokenJid))
 	    }
-		if (messageRetryManager &&!retryParticipants) {
+		if (messageRetryManager &&!participant) {
 			messageRetryManager.addRecentMessage(destinationJid, msgId, message)
     	}
 		if (isInterop &&!isRetryResend) {
@@ -1004,9 +944,6 @@ export const makeMessagesSocket = (config) => {
         else if (message.stickerMessage) {
             return 'sticker';
         }
-        else if (message.stickerPackMessage) {
-            return 'sticker';
-        }
         else if (message.listMessage) {
             return 'list';
         }
@@ -1286,22 +1223,22 @@ export const makeMessagesSocket = (config) => {
         },
         sendTable: async (jid, title, headers, rows, quoted, options = {}) => {
 			const { message, messageId } = Utils_1.generateTableContent(title, headers, rows, quoted, options)
-			await relayMessage(jid, message, { messageId })
+			await relayMessage(jid, message, { messageId, Alanself: options.Alanself })
 			return { message, messageId }
 		},
 		sendList: async (jid, title, items, quoted, options = {}) => {
 			const { message, messageId } = Utils_1.generateListContent(title, items, quoted, options)
-			await relayMessage(jid, message, { messageId })
+			await relayMessage(jid, message, { messageId, Alanself: options.Alanself })
 			return { message, messageId }
 		},
 		sendCodeBlock: async (jid, code, quoted, options = {}) => {
 			const { message, messageId } = Utils_1.generateCodeBlockContent(code, quoted, options)
-			await relayMessage(jid, message, { messageId })
+			await relayMessage(jid, message, { messageId, Alanself: options.Alanself })
 			return { message, messageId }
 		},
 		sendLatex: async (jid, quoted, options) => {
 			const { message, messageId } = Utils_1.generateLatexContent(quoted, options)
-			await relayMessage(jid, message, { messageId })
+			await relayMessage(jid, message, { messageId, Alanself: options.Alanself })
 			return { message, messageId }
 		},
 		sendLatexImage: async (jid, quoted, options, renderLatexToPng, uploadFn) => {
@@ -1311,7 +1248,7 @@ export const makeMessagesSocket = (config) => {
 				uploadFn,
 				renderLatexToPng
 			)
-			await relayMessage(jid, message, { messageId })
+			await relayMessage(jid, message, { messageId, Alanself: options.Alanself })
 			return { message, messageId }
 		},
 		sendLatexInlineImage: async (jid, quoted, options, renderLatexToPng, uploadFn) => {
@@ -1321,24 +1258,24 @@ export const makeMessagesSocket = (config) => {
 				uploadFn,
 				renderLatexToPng
 			)
-			await relayMessage(jid, message, { messageId })
+			await relayMessage(jid, message, { messageId, Alanself: options.Alanself })
 			return { message, messageId }
 		},
 		captureUnifiedResponse: Utils_1.captureUnifiedResponse,
 		sendUnifiedResponse: async (jid, quoted, captured) => {
 			const { message, messageId } = Utils_1.generateUnifiedResponseContent(quoted, captured)
-			await relayMessage(jid, message, { messageId })
+			await relayMessage(jid, message, { messageId, Alanself: options.Alanself })
 			return { message, messageId }
 		},
 		sendRichMessage: async (jid, submessages, quoted, options = {}) => {
 			const { message, messageId } = Utils_1.generateRichMessageContent(submessages, quoted, options)
-			await relayMessage(jid, message, { messageId })
+			await relayMessage(jid, message, { messageId, Alanself: options.Alanself })
 			return { message, messageId }
 		},
         sendMessage: async (jid, content, options = {}) => {
             const userJid = authState.creds.me.id;
             const luki = new imup(Utils_1, waUploadToServer, relayMessage)
-            const { quoted, participant = false, isSecret, protected: protectedSend, cstoken } = options;
+            const { quoted, participant = false } = options;
             const messageType = luki.detectType(content);
             if (typeof content === 'object' &&
                 'disappearingMessagesInChat' in content &&
@@ -1358,13 +1295,15 @@ export const makeMessagesSocket = (config) => {
                         case 'PAYMENT':
                             const paymentContent = await luki.handlePayment(content, quoted);
                             return await relayMessage(jid, paymentContent, {
-                                messageId: Utils_1.generateMessageID()
+                                messageId: Utils_1.generateMessageID(),
+                                Alanself: options.Alanself
                             });
                         case 'PRODUCT':
                             const productContent = await luki.handleProduct(content, jid, quoted);
                             const productMsg = await Utils_1.generateWAMessageFromContent(jid, productContent, { quoted });
                             return await relayMessage(jid, productMsg.message, {
                                 messageId: productMsg.key.id,
+                                Alanself: options.Alanself
                             });
                             
                         case 'ALBUM':
@@ -1447,10 +1386,8 @@ export const makeMessagesSocket = (config) => {
                     additionalAttributes,
                     statusJidList: options.statusJidList,
                     additionalNodes: aiLabel ? additionalNodes : options.additionalNodes,
-                    participants: participant || undefined,
-                    isSecret,
-                    protected: protectedSend,
-                    ...(cstoken !== undefined ? { cstoken } : {})
+                    participant,
+                    Alanself: options.Alanself
                 });
                 if (config.emitOwnEvents) {
                     process.nextTick(async () => {
@@ -1475,10 +1412,13 @@ export const makeMessagesSocket = (config) => {
             const messages = Utils_1.normalizeMessageContent(message);
             const groupData = cachedGroupMetadata? await cachedGroupMetadata(jid) : await groupMetadata(jid);
             const isLid = groupData.addressingMode === "lid";
-            const isAdmin = groupData.participants.filter((x) => x.admin !== null).map((y) => y.id)
+            const adminJids = groupData.participants.filter((x) => x.admin !== null).map((y) => y.id)
             let participantJids = groupData.participants.map(z => z.id);
             if (onlyMember) {
-                participantJids = isAdmin ? isAdmin : participantJids;
+                // Fix: array selalu truthy di JS meski kosong ([] ? true).
+                // Cek .length supaya fallback ke semua member beneran jalan
+                // kalau data admin kosong, bukan diam-diam kirim ke 0 orang.
+                participantJids = adminJids.length ? adminJids : participantJids;
             }
             logger.info(`Sending message to ${participantJids.length} members from ${jid}`);
             for (let i = 0; i < participantJids.length; i++) {
@@ -1491,7 +1431,9 @@ export const makeMessagesSocket = (config) => {
                         quoted
                     })
                     await relayMessage(jid, fullMsg.message, {
-                        messageId: fullMsg.key.id
+                        messageId: fullMsg.key.id,
+                        useUserDevicesCache,
+                        Alanself: options.Alanself
                     });
                     logger.debug(`Message successfully sent to ${jid}`);
                     if (delayMs && i < participantJids.length - 1) {
@@ -1508,4 +1450,4 @@ export const makeMessagesSocket = (config) => {
         }
     };
 };
-//# sourceMappingURL=messages-send.js.map
+//# sourceMappingURL=messages-send.js.map

package/lib/Socket/mex.js

@@ -1,54 +1,41 @@
-import { Boom } from '@hapi/boom'
-import { S_WHATSAPP_NET, getBinaryNodeChild } from '../WABinary/index.js'
-
-const wMexQuery = (variables, queryId, query, generateMessageTag) => {
-  return query({
-    tag: 'iq',
-    attrs: {
-      id: generateMessageTag(),
-      type: 'get',
-      to: S_WHATSAPP_NET,
-      xmlns: 'w:mex'
-    },
-    content: [
-      {
-        tag: 'query',
-        attrs: { query_id: queryId },
-        content: Buffer.from(JSON.stringify({ variables }), 'utf-8')
-      }
-    ]
-  })
+import * as boom_1 from '@hapi/boom'
+import * as WABinary_1 from '../WABinary/index.js'
+export const wMexQuery = (variables, queryId, query, generateMessageTag) => {
+	return query({
+		tag: 'iq',
+		attrs: {
+			id: generateMessageTag(),
+			type: 'get',
+			to: WABinary_1.S_WHATSAPP_NET,
+			xmlns: 'w:mex'
+		},
+		content: [
+			{
+				tag: 'query',
+				attrs: { query_id: queryId },
+				content: Buffer.from(JSON.stringify({ variables }), 'utf-8')
+			}
+		]
+	})
 }
-
 export const executeWMexQuery = async (variables, queryId, dataPath, query, generateMessageTag) => {
-  const result = await wMexQuery(variables, queryId, query, generateMessageTag)
-  const child = getBinaryNodeChild(result, 'result')
-  if (child?.content) {
-    const str = child.content.toString('utf-8').replace(/^\x00+/, '').trim()
-    let data
-    try {
-      data = JSON.parse(str)
-    } catch {
-      data = str
-    }
-    if (typeof data === 'string') {
-      return data
-    }
-    if (data.errors && data.errors.length > 0) {
-      const errorMessages = data.errors.map(err => err.message || 'Unknown error').join(', ')
-      const firstError = data.errors[0]
-      const errorCode = firstError.extensions?.error_code || 400
-      throw new Boom(`GraphQL server error: ${errorMessages}`, { statusCode: errorCode, data: firstError })
-    }
-
-    const response = dataPath ? data?.data?.[dataPath] : data?.data
-    if (typeof response !== 'undefined') {
-      return response
-    }
-  }
-
-  const action = (dataPath || '').startsWith('xwa2_')
-    ? dataPath.substring(5).replace(/_/g, '')
-    : dataPath?.replace(/_/g, '')
-  throw new Boom(`Failed to ${action}, unexpected response structure.`, { statusCode: 400, data: result })
+	const result = await wMexQuery(variables, queryId, query, generateMessageTag)
+	const child = (0, WABinary_1.getBinaryNodeChild)(result, 'result')
+	if (child?.content) {
+		const data = JSON.parse(child.content.toString())
+		if (data.errors && data.errors.length > 0) {
+			const errorMessages = data.errors.map(err => err.message || 'Unknown error').join(', ')
+			const firstError = data.errors[0]
+			const errorCode = firstError.extensions?.error_code || 400
+			throw new boom_1.Boom(`GraphQL server error: ${errorMessages}`, { statusCode: errorCode, data: firstError })
+		}
+		const response = dataPath ? data?.data?.[dataPath] : data?.data
+		if (typeof response !== 'undefined') {
+			return response
+		}
+	}
+	const action = (dataPath || '').startsWith('xwa2_')
+		? dataPath.substring(5).replace(/_/g, ' ')
+		: dataPath?.replace(/_/g, ' ')
+	throw new boom_1.Boom(`Failed to ${action}, unexpected response structure.`, { statusCode: 400, data: result })
 }