@badzz88/baileys 8.5.6 → 8.5.7

package/lib/Utils/history.js

@@ -0,0 +1,244 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.getHistoryMsg =
+	exports.downloadAndProcessHistorySyncNotification =
+	exports.processHistoryMessage =
+	exports.downloadHistory =
+		void 0
+const util_1 = require('util')
+const zlib_1 = require('zlib')
+const index_js_1 = require('../../WAProto/index.js')
+const Types_1 = require('../Types')
+const WABinary_1 = require('../WABinary')
+const generics_1 = require('./generics')
+const messages_1 = require('./messages')
+const messages_media_1 = require('./messages-media')
+const inflatePromise = (0, util_1.promisify)(zlib_1.inflate)
+const extractPnFromMessages = messages => {
+	for (const msgItem of messages) {
+		const message = msgItem.message
+		// Only extract from outgoing messages (fromMe: true) in 1:1 chats
+		// because userReceipt.userJid is the recipient's JID
+		if (!message?.key?.fromMe || !message.userReceipt?.length) {
+			continue
+		}
+		const userJid = message.userReceipt[0]?.userJid
+		if (userJid && ((0, WABinary_1.isPnUser)(userJid) || (0, WABinary_1.isHostedPnUser)(userJid))) {
+			return userJid
+		}
+	}
+	return undefined
+}
+const downloadHistory = async (msg, options) => {
+	const stream = await (0, messages_media_1.downloadContentFromMessage)(msg, 'md-msg-hist', { options })
+	const bufferArray = []
+	for await (const chunk of stream) {
+		bufferArray.push(chunk)
+	}
+	let buffer = Buffer.concat(bufferArray)
+	// decompress buffer
+	buffer = await inflatePromise(buffer)
+	const syncData = index_js_1.proto.HistorySync.decode(buffer)
+	return syncData
+}
+exports.downloadHistory = downloadHistory
+const processHistoryMessage = (item, logger) => {
+	const messages = []
+	const contacts = []
+	const chats = []
+	const lidPnMappings = []
+	const callLogRecords = []
+	const pastParticipants = []
+	const recentStickers = []
+	let globalSettings = undefined
+	let statusV3Messages = undefined
+	logger?.trace({ progress: item.progress }, 'processing history of type ' + item.syncType?.toString())
+	// Extract LID-PN mappings for all sync types
+	for (const m of item.phoneNumberToLidMappings || []) {
+		if (m.lidJid && m.pnJid) {
+			lidPnMappings.push({ lid: m.lidJid, pn: m.pnJid })
+		}
+	}
+	// Extract inline contacts (LID-PN mappings with names)
+	for (const c of item.inlineContacts || []) {
+		if (c.lidJid && c.pnJid) {
+			lidPnMappings.push({ lid: c.lidJid, pn: c.pnJid })
+		}
+		if (c.pnJid) {
+			contacts.push({
+				id: c.pnJid,
+				name: c.fullName || c.firstName || c.username || undefined,
+				notify: c.pushname || undefined,
+				username: c.username || undefined,
+				shortName: c.shortName || undefined,
+				verifiedName: c.verifiedBizName || undefined,
+				businessName: c.verifiedBizName || undefined,
+				lid: c.lidJid || undefined
+			})
+		}
+	}
+	// Extract call log records with richer metadata
+	for (const rec of item.callLogRecords || []) {
+		callLogRecords.push({
+			...rec,
+			callType: rec.callType,
+			duration: rec.duration ? (0, generics_1.toNumber)(rec.duration) : undefined,
+			isVideo: rec.isVideo,
+			callInitiator: rec.callInitiatorJid,
+			callEndReason: rec.callResult,
+			timestamp: rec.startTime ? (0, generics_1.toNumber)(rec.startTime) : undefined
+		})
+	}
+	// Extract recent stickers with metadata, deduped by key
+	const stickerKeys = new Set()
+	for (const s of item.recentStickers || []) {
+		const stickerKey = s.fileSha256 ? Buffer.from(s.fileSha256).toString('base64') : undefined
+		if (!stickerKey || !stickerKeys.has(stickerKey)) {
+			if (stickerKey) stickerKeys.add(stickerKey)
+			recentStickers.push(s)
+		}
+	}
+	switch (item.syncType) {
+		case index_js_1.proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP:
+		case index_js_1.proto.HistorySync.HistorySyncType.RECENT:
+		case index_js_1.proto.HistorySync.HistorySyncType.FULL:
+		case index_js_1.proto.HistorySync.HistorySyncType.ON_DEMAND:
+			// Extract global client settings with full field parsing
+			if (item.globalSettings) {
+				const gs = item.globalSettings
+				globalSettings = {
+					...gs,
+					// Parsed convenience fields
+					autoDownloadSettings: {
+						photos: gs.autoDownloadPhotos,
+						audio: gs.autoDownloadAudio,
+						documents: gs.autoDownloadDocuments,
+						videos: gs.autoDownloadVideos
+					},
+					disappearingMode: gs.disappearingMode
+						? {
+								duration: gs.disappearingMode.duration
+									? (0, generics_1.toNumber)(gs.disappearingMode.duration)
+									: undefined,
+								isDefaultDisappearingMode: gs.disappearingMode.isDefaultDisappearingMode ?? false
+							}
+						: undefined,
+					archiveChats: gs.archiveChats,
+					wallpaper: gs.wallpaper,
+					mediaEncryptionBackupEnabled: gs.mediaEncryptionBackupEnabled,
+					lightWeightContactsEnabled: gs.lightWeightContactsEnabled,
+					privacySettings: gs.privacy
+						? {
+								readReceipts: gs.privacy.readreceipts,
+								lastSeen: gs.privacy.lastseen,
+								status: gs.privacy.status,
+								profile: gs.privacy.profile,
+								groupsAddPrivacy: gs.privacy.groupadd,
+								callPrivacy: gs.privacy.calladd
+							}
+						: undefined
+				}
+			}
+			// Extract status V3 messages with expiry tracking
+			if (item.statusV3Messages?.length) {
+				const now = Math.floor(Date.now() / 1000)
+				statusV3Messages = item.statusV3Messages.filter(s => {
+					const ts = s.message?.messageTimestamp
+					if (!ts) return true
+					const timestamp = (0, generics_1.toNumber)(ts)
+					return timestamp + 24 * 60 * 60 > now
+				})
+			}
+			for (const chat of item.conversations) {
+				contacts.push({
+					id: chat.id,
+					name: chat.displayName || chat.name || chat.username || undefined,
+					username: chat.username || undefined,
+					lid: chat.lidJid || chat.accountLid || undefined,
+					phoneNumber: chat.pnJid || undefined
+				})
+				const chatId = chat.id
+				const isLid = (0, WABinary_1.isLidUser)(chatId) || (0, WABinary_1.isHostedLidUser)(chatId)
+				const isPn = (0, WABinary_1.isPnUser)(chatId) || (0, WABinary_1.isHostedPnUser)(chatId)
+				if (isLid && chat.pnJid) {
+					lidPnMappings.push({ lid: chatId, pn: chat.pnJid })
+				} else if (isPn && chat.lidJid) {
+					lidPnMappings.push({ lid: chat.lidJid, pn: chatId })
+				} else if (isLid && !chat.pnJid) {
+					// Fallback: extract PN from userReceipt in messages when pnJid is missing
+					const pnFromReceipt = extractPnFromMessages(chat.messages || [])
+					if (pnFromReceipt) {
+						lidPnMappings.push({ lid: chatId, pn: pnFromReceipt })
+					}
+				}
+				const msgs = chat.messages || []
+				delete chat.messages
+				for (const item of msgs) {
+					const message = item.message
+					messages.push(message)
+					if (!chat.messages?.length) {
+						// keep only the most recent message in the chat array
+						chat.messages = [{ message }]
+					}
+					if (!message.key.fromMe && !chat.lastMessageRecvTimestamp) {
+						chat.lastMessageRecvTimestamp = (0, generics_1.toNumber)(message.messageTimestamp)
+					}
+					if (
+						(message.messageStubType === Types_1.WAMessageStubType.BIZ_PRIVACY_MODE_TO_BSP ||
+							message.messageStubType === Types_1.WAMessageStubType.BIZ_PRIVACY_MODE_TO_FB) &&
+						message.messageStubParameters?.[0]
+					) {
+						contacts.push({
+							id: message.key.participant || message.key.remoteJid,
+							verifiedName: message.messageStubParameters?.[0]
+						})
+					}
+				}
+				// Extract past participants metadata
+				if (chat.id && (0, WABinary_1.isJidGroup)(chat.id)) {
+					// Chat-level past participants info is available via PastParticipants messages
+				}
+				chats.push({ ...chat })
+			}
+			// Extract past participants from dedicated field
+			for (const pp of item.pastParticipants || []) {
+				pastParticipants.push(pp)
+			}
+			break
+		case index_js_1.proto.HistorySync.HistorySyncType.PUSH_NAME:
+			for (const c of item.pushnames) {
+				contacts.push({ id: c.id, notify: c.pushname })
+			}
+			break
+	}
+	return {
+		chats,
+		contacts,
+		messages,
+		lidPnMappings,
+		syncType: item.syncType,
+		progress: item.progress,
+		globalSettings,
+		callLogRecords,
+		recentStickers,
+		pastParticipants,
+		statusV3Messages
+	}
+}
+exports.processHistoryMessage = processHistoryMessage
+const downloadAndProcessHistorySyncNotification = async (msg, options, logger) => {
+	let historyMsg
+	if (msg.initialHistBootstrapInlinePayload) {
+		historyMsg = index_js_1.proto.HistorySync.decode(await inflatePromise(msg.initialHistBootstrapInlinePayload))
+	} else {
+		historyMsg = await (0, exports.downloadHistory)(msg, options)
+	}
+	return (0, exports.processHistoryMessage)(historyMsg, logger)
+}
+exports.downloadAndProcessHistorySyncNotification = downloadAndProcessHistorySyncNotification
+const getHistoryMsg = message => {
+	const normalizedContent = !!message ? (0, messages_1.normalizeMessageContent)(message) : undefined
+	const anyHistoryMsg = normalizedContent?.protocolMessage?.historySyncNotification
+	return anyHistoryMsg
+}
+exports.getHistoryMsg = getHistoryMsg

package/lib/Utils/identity-change-handler.js

@@ -0,0 +1,52 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.handleIdentityChange = handleIdentityChange
+const WABinary_1 = require('../WABinary')
+const generics_1 = require('./generics')
+async function handleIdentityChange(node, ctx) {
+	const from = node.attrs.from
+	if (!from) {
+		return { action: 'invalid_notification' }
+	}
+	const identityNode = (0, WABinary_1.getBinaryNodeChild)(node, 'identity')
+	if (!identityNode) {
+		return { action: 'no_identity_node' }
+	}
+	ctx.logger.info({ jid: from }, 'identity changed')
+	const decoded = (0, WABinary_1.jidDecode)(from)
+	if (decoded?.device && decoded.device !== 0) {
+		ctx.logger.debug({ jid: from, device: decoded.device }, 'ignoring identity change from companion device')
+		return { action: 'skipped_companion_device', device: decoded.device }
+	}
+	const isSelfPrimary =
+		ctx.meId &&
+		((0, WABinary_1.areJidsSameUser)(from, ctx.meId) || (ctx.meLid && (0, WABinary_1.areJidsSameUser)(from, ctx.meLid)))
+	if (isSelfPrimary) {
+		ctx.logger.info({ jid: from }, 'self primary identity changed')
+		return { action: 'skipped_self_primary' }
+	}
+	if (ctx.debounceCache.get(from)) {
+		ctx.logger.debug({ jid: from }, 'skipping identity assert (debounced)')
+		return { action: 'debounced' }
+	}
+	ctx.debounceCache.set(from, true)
+	const isOfflineNotification = !(0, generics_1.isStringNullOrEmpty)(node.attrs.offline)
+	const hasExistingSession = await ctx.validateSession(from)
+	if (!hasExistingSession.exists) {
+		ctx.logger.debug({ jid: from }, 'no old session, skipping session refresh')
+		return { action: 'skipped_no_session' }
+	}
+	ctx.logger.debug({ jid: from }, 'old session exists, will refresh session')
+	if (isOfflineNotification) {
+		ctx.logger.debug({ jid: from }, 'skipping session refresh during offline processing')
+		return { action: 'skipped_offline' }
+	}
+	ctx.onBeforeSessionRefresh?.(from)
+	try {
+		await ctx.assertSessions([from], true)
+		return { action: 'session_refreshed' }
+	} catch (error) {
+		ctx.logger.warn({ error, jid: from }, 'failed to assert sessions after identity change')
+		return { action: 'session_refresh_failed', error }
+	}
+}

package/lib/Utils/index.js

@@ -0,0 +1,57 @@
+'use strict'
+var __createBinding =
+	(this && this.__createBinding) ||
+	(Object.create
+		? function (o, m, k, k2) {
+				if (k2 === undefined) k2 = k
+				var desc = Object.getOwnPropertyDescriptor(m, k)
+				if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+					desc = {
+						enumerable: true,
+						get: function () {
+							return m[k]
+						}
+					}
+				}
+				Object.defineProperty(o, k2, desc)
+			}
+		: function (o, m, k, k2) {
+				if (k2 === undefined) k2 = k
+				o[k2] = m[k]
+			})
+var __exportStar =
+	(this && this.__exportStar) ||
+	function (m, exports) {
+		for (var p in m)
+			if (p !== 'default' && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p)
+	}
+Object.defineProperty(exports, '__esModule', { value: true })
+__exportStar(require('./generics'), exports)
+__exportStar(require('./decode-wa-message'), exports)
+__exportStar(require('./messages'), exports)
+__exportStar(require('./messages-media'), exports)
+__exportStar(require('./validate-connection'), exports)
+__exportStar(require('./crypto'), exports)
+__exportStar(require('./signal'), exports)
+__exportStar(require('./noise-handler'), exports)
+__exportStar(require('./history'), exports)
+__exportStar(require('./chat-utils'), exports)
+__exportStar(require('./lt-hash'), exports)
+__exportStar(require('./auth-utils'), exports)
+__exportStar(require('./use-multi-file-auth-state'), exports)
+__exportStar(require('./link-preview'), exports)
+__exportStar(require('./event-buffer'), exports)
+__exportStar(require('./process-message'), exports)
+__exportStar(require('./message-retry-manager'), exports)
+__exportStar(require('./browser-utils'), exports)
+__exportStar(require('./identity-change-handler'), exports)
+__exportStar(require('./stanza-ack'), exports)
+__exportStar(require('./message-composer'), exports)
+__exportStar(require('./group-history'), exports)
+__exportStar(require('./consumer-application'), exports)
+__exportStar(require('./voip-rekey'), exports)
+__exportStar(require('./companion-reg-client-utils'), exports)
+__exportStar(require('./view-once-cache'), exports)
+__exportStar(require('./sticker'), exports)
+__exportStar(require('./command-loader'), exports)
+__exportStar(require('./session-pool'), exports)

package/lib/Utils/jid-display-normalization.js

@@ -0,0 +1,218 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.normalizeMessageForDisplayJids = void 0
+exports.normalizeMentionedJidsForSend = void 0
+
+const WABinary_1 = require('../WABinary')
+
+const createLidPnDebug = logger => {
+	const enabled = process.env.LID_PN_DEBUG === '1' || process.env.LID_PN_DEBUG === 'true'
+	return (phase, payload) => {
+		if (!enabled) {
+			return
+		}
+		logger?.debug({ ...payload, phase }, 'lid->pn normalization trace')
+	}
+}
+
+const fallbackPnFromLidJid = jid => {
+	const decoded = (0, WABinary_1.jidDecode)(jid)
+	const rawUser = decoded?.user || (typeof jid === 'string' ? jid.split('@')[0] : '')
+	const user = rawUser.split(':')[0]
+	if (!user) {
+		return jid
+	}
+	return `${user}@s.whatsapp.net`
+}
+
+const toDisplayPnJid = jid => {
+	if (!jid || typeof jid !== 'string') {
+		return jid
+	}
+	const decoded = (0, WABinary_1.jidDecode)(jid)
+	if (!decoded?.user) {
+		return jid
+	}
+	if (!(0, WABinary_1.isPnUser)(jid) && !(0, WABinary_1.isHostedPnUser)(jid)) {
+		return jid
+	}
+	const user = decoded.user.split(':')[0]
+	if (!user) {
+		return jid
+	}
+	const server = decoded.server === 'hosted' ? 'hosted' : 's.whatsapp.net'
+	return `${user}@${server}`
+}
+
+const buildLidPnHints = key => {
+	const hints = new Map()
+	if (!key) {
+		return hints
+	}
+	const addHint = (lid, pn) => {
+		if (!(0, WABinary_1.isLidUser)(lid) && !(0, WABinary_1.isHostedLidUser)(lid)) {
+			return
+		}
+		if (!(0, WABinary_1.isPnUser)(pn) && !(0, WABinary_1.isHostedPnUser)(pn)) {
+			return
+		}
+		hints.set(lid, pn)
+		const lidDecoded = (0, WABinary_1.jidDecode)(lid)
+		const pnDecoded = (0, WABinary_1.jidDecode)(pn)
+		if (lidDecoded?.user && pnDecoded?.user) {
+			hints.set(`${lidDecoded.user}@lid`, `${pnDecoded.user}@s.whatsapp.net`)
+		}
+	}
+	addHint(key.participant, key.participantAlt)
+	addHint(key.remoteJid, key.remoteJidAlt)
+	addHint(key.participantAlt, key.participant)
+	addHint(key.remoteJidAlt, key.remoteJid)
+	return hints
+}
+
+const mergeGroupDataHints = (hints, groupData, debug) => {
+	if (!groupData?.participants?.length) {
+		return
+	}
+	debug?.('groupData-size', { participants: groupData.participants.length })
+	for (const participant of groupData.participants) {
+		const lidCandidate = participant?.lid
+		const idCandidate = participant?.id
+		const pnCandidate = participant?.phoneNumber
+		const lid =
+			((0, WABinary_1.isLidUser)(lidCandidate) || (0, WABinary_1.isHostedLidUser)(lidCandidate)
+				? lidCandidate
+				: undefined) ||
+			((0, WABinary_1.isLidUser)(idCandidate) || (0, WABinary_1.isHostedLidUser)(idCandidate) ? idCandidate : undefined)
+		const pn =
+			((0, WABinary_1.isPnUser)(pnCandidate) || (0, WABinary_1.isHostedPnUser)(pnCandidate)
+				? pnCandidate
+				: undefined) ||
+			((0, WABinary_1.isPnUser)(idCandidate) || (0, WABinary_1.isHostedPnUser)(idCandidate) ? idCandidate : undefined)
+		if (!lid || !pn) {
+			continue
+		}
+		if (
+			((0, WABinary_1.isLidUser)(lid) || (0, WABinary_1.isHostedLidUser)(lid)) &&
+			((0, WABinary_1.isPnUser)(pn) || (0, WABinary_1.isHostedPnUser)(pn))
+		) {
+			const displayPn = toDisplayPnJid(pn)
+			hints.set(lid, displayPn)
+			const lidDecoded = (0, WABinary_1.jidDecode)(lid)
+			if (lidDecoded?.user) {
+				hints.set(`${lidDecoded.user}@lid`, displayPn)
+			}
+			debug?.('group-hint', { lid, pn: displayPn })
+		}
+	}
+}
+
+const normalizeToPnJid = async (jid, hints, signalRepository, debug) => {
+	if (!jid || typeof jid !== 'string') {
+		return jid
+	}
+	if (!(0, WABinary_1.isLidUser)(jid) && !(0, WABinary_1.isHostedLidUser)(jid)) {
+		return jid
+	}
+	debug?.('input', { lid: jid })
+	const hinted = hints.get(jid)
+	if (hinted) {
+		const normalized = toDisplayPnJid(hinted)
+		debug?.('hint-exact', { lid: jid, hinted, normalized })
+		return normalized
+	}
+	const decoded = (0, WABinary_1.jidDecode)(jid)
+	if (decoded?.user) {
+		const userHint = hints.get(`${decoded.user}@lid`)
+		if (userHint) {
+			const normalized = toDisplayPnJid(userHint)
+			debug?.('hint-user', { lid: jid, userHint, normalized })
+			return normalized
+		}
+	}
+	const mapped = await signalRepository?.lidMapping?.getPNForLID?.(jid)
+	if (mapped) {
+		const normalized = toDisplayPnJid(mapped)
+		debug?.('mapping', { lid: jid, mapped, normalized })
+		return normalized
+	}
+	const fallback = fallbackPnFromLidJid(jid)
+	debug?.('fallback', { lid: jid, fallback })
+	return fallback
+}
+
+const normalizeMentionedJidsToPn = async (node, hints, signalRepository, debug) => {
+	if (!node || typeof node !== 'object') {
+		return
+	}
+	if (Array.isArray(node)) {
+		for (const item of node) {
+			await normalizeMentionedJidsToPn(item, hints, signalRepository, debug)
+		}
+		return
+	}
+	if (Array.isArray(node.mentionedJid)) {
+		const before = [...node.mentionedJid]
+		node.mentionedJid = await Promise.all(
+			node.mentionedJid.map(jid => normalizeToPnJid(jid, hints, signalRepository, debug))
+		)
+		debug?.('mentions', { before, after: node.mentionedJid })
+	}
+	if (typeof node.participant === 'string') {
+		const before = node.participant
+		node.participant = await normalizeToPnJid(node.participant, hints, signalRepository, debug)
+		if (before !== node.participant) {
+			debug?.('participant-field', { before, after: node.participant })
+		}
+	}
+	if (typeof node.remoteJid === 'string') {
+		const before = node.remoteJid
+		node.remoteJid = await normalizeToPnJid(node.remoteJid, hints, signalRepository, debug)
+		if (before !== node.remoteJid) {
+			debug?.('remoteJid-field', { before, after: node.remoteJid })
+		}
+	}
+	for (const value of Object.values(node)) {
+		if (value && typeof value === 'object') {
+			await normalizeMentionedJidsToPn(value, hints, signalRepository, debug)
+		}
+	}
+}
+
+const normalizeMentionedJidsForSend = async (mentions, groupData, signalRepository, logger) => {
+	if (!Array.isArray(mentions)) {
+		return mentions
+	}
+	const debug = createLidPnDebug(logger)
+	const hints = new Map()
+	mergeGroupDataHints(hints, groupData, debug)
+	const normalized = await Promise.all(mentions.map(jid => normalizeToPnJid(jid, hints, signalRepository, debug)))
+	debug('send-mentions-result', { before: mentions, after: normalized })
+	return normalized
+}
+
+const normalizeMessageForDisplayJids = async (messageInfo, signalRepository, logger, groupData) => {
+	if (!messageInfo?.key) {
+		return messageInfo
+	}
+	const debug = createLidPnDebug(logger)
+	const hints = buildLidPnHints(messageInfo.key)
+	mergeGroupDataHints(hints, groupData, debug)
+	const beforeKey = { ...messageInfo.key }
+	messageInfo.key.participant = await normalizeToPnJid(messageInfo.key.participant, hints, signalRepository, debug)
+	messageInfo.key.participantAlt = await normalizeToPnJid(
+		messageInfo.key.participantAlt,
+		hints,
+		signalRepository,
+		debug
+	)
+	messageInfo.key.remoteJid = await normalizeToPnJid(messageInfo.key.remoteJid, hints, signalRepository, debug)
+	messageInfo.key.remoteJidAlt = await normalizeToPnJid(messageInfo.key.remoteJidAlt, hints, signalRepository, debug)
+	await normalizeMentionedJidsToPn(messageInfo.message, hints, signalRepository, debug)
+	debug('display-key-result', { before: beforeKey, after: messageInfo.key })
+	return messageInfo
+}
+
+exports.normalizeMessageForDisplayJids = normalizeMessageForDisplayJids
+exports.normalizeMentionedJidsForSend = normalizeMentionedJidsForSend