import path from 'path'; import { mkdirSync, writeFileSync } from 'fs'; import { randomBytes } from 'crypto'; import { format } from 'util'; export const MIME_MAP = { jpg: 'image/jpeg', jpeg: 'image/jpeg', png: 'image/png', webp: 'image/webp', gif: 'image/gif', mp4: 'video/mp4', mov: 'video/quicktime', avi: 'video/x-msvideo', mkv: 'video/x-matroska', '3gp': 'video/3gpp', pdf: 'application/pdf', doc: 'application/msword', docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', }; export function normalizeWhatsAppId(value) { if (!value) return ''; // Baileys reports the bot's own ids device-qualified (`:@lid`), while // inbound mentionedJid / contextInfo.participant are not. Drop the suffix so both // forms compare equal; the old `':' -> '@'` swap produced `@@lid`, // which never matched and silently broke @mention / reply-to-bot gating in groups. return String(value).replace(/:\d+(?=@)/, '').replace(/:\d+$/, ''); } function unwrapMessageEnvelopes(content) { let cur = content; // Envelopes nest (ephemeral wrapping viewOnce wrapping the payload); peel // until an inner message is reached so nested quotes resolve too. for (let i = 0; i < 8 && cur; i++) { const next = cur.ephemeralMessage?.message ?? cur.viewOnceMessage?.message ?? cur.viewOnceMessageV2?.message ?? cur.documentWithCaptionMessage?.message; if (next === undefined) break; cur = next; } return cur; } export function getMessageContent(msg) { const raw = msg?.message || {}; const content = unwrapMessageEnvelopes(raw); // A peeled envelope returns its inner message immediately: the payload // shape (template/buttons/list/etc.) applies to unenveloped messages. if (content !== raw) return content; if (content.templateMessage?.hydratedTemplate) return content.templateMessage.hydratedTemplate; if (content.buttonsMessage) return content.buttonsMessage; if (content.listMessage) return content.listMessage; return content; } export function getContextInfo(messageContent) { if (!messageContent || typeof messageContent !== 'object') return {}; for (const value of Object.values(messageContent)) { if (value && typeof value === 'object' && value.contextInfo) { return value.contextInfo; } } return {}; } export function createBoundedMessageStore(limit = 512) { const byId = new Map(); function remember(msg) { const id = msg?.key?.id; if (!id) return; byId.delete(id); byId.set(id, msg); while (byId.size > limit) { const oldest = byId.keys().next().value; byId.delete(oldest); } } function get(id) { if (!id || !byId.has(id)) return null; const msg = byId.get(id); byId.delete(id); byId.set(id, msg); return msg; } return { remember, get }; } /** * Bounded cache of the already-downloaded media (and plain text) for * recently seen inbound messages, keyed by "chatId:messageId". * * When a user replies to an earlier message, Baileys' contextInfo.quotedMessage * only carries a thumbnail-sized stub for media (or nothing at all for an * uncaptioned attachment) — never a way to re-fetch the full original file. * Without this cache, replying to a photo/video/document/voice note with no * caption gives the agent no text and no media reference: it looks like the * message never had an attachment. Since extractBridgeEvent already downloads * and caches the media for every inbound message as it arrives, remembering * that outcome here lets a later reply resolve the original file path. */ export function createQuotedMediaCache(limit = 512) { const byKey = new Map(); function key(chatId, messageId) { return `${chatId || ''}:${messageId || ''}`; } function remember(chatId, messageId, payload) { if (!messageId) return; const k = key(chatId, messageId); byKey.delete(k); byKey.set(k, payload); while (byKey.size > limit) { const oldest = byKey.keys().next().value; byKey.delete(oldest); } } function get(chatId, messageId) { if (!messageId) return null; return byKey.get(key(chatId, messageId)) || null; } return { remember, get }; } export function pollCreationMessageSecret(pollCreation) { return pollCreation?.message?.messageContextInfo?.messageSecret || pollCreation?.messageContextInfo?.messageSecret || null; } function uniqueStrings(values) { const seen = new Set(); const out = []; for (const value of values || []) { const text = String(value || '').trim(); if (!text || seen.has(text)) continue; seen.add(text); out.push(text); } return out; } export function pollUpdateForAggregation({ pollUpdateMessage, pollUpdateMessageKey, pollCreation, decryptPollVote, getKeyAuthor, meId = 'me', pollCreatorJids = [], voterJids = [], }) { if (!pollUpdateMessage) return null; const updateKey = pollUpdateMessage.pollUpdateMessageKey || pollUpdateMessageKey || pollUpdateMessage.key; if (!updateKey) return null; if (pollUpdateMessage.vote?.selectedOptions) { return { pollUpdateMessageKey: updateKey, vote: pollUpdateMessage.vote, senderTimestampMs: pollUpdateMessage.senderTimestampMs, }; } const creationKey = pollUpdateMessage.pollCreationMessageKey; const secret = pollCreationMessageSecret(pollCreation); if ( !creationKey?.id || !secret || !pollUpdateMessage.vote?.encPayload || !pollUpdateMessage.vote?.encIv || typeof decryptPollVote !== 'function' || typeof getKeyAuthor !== 'function' ) { return null; } // Baileys poll decryption keys include both creator and voter JIDs. On // WhatsApp LID chats, the poll creator can be the linked-device LID even // when sock.user.id is the classic @s.whatsapp.net JID. Try the exact // candidates the live bridge knows before falling back to the generic helper. const creatorCandidates = uniqueStrings([ ...pollCreatorJids, getKeyAuthor(creationKey, meId), ]); const voterCandidates = uniqueStrings([ ...voterJids, getKeyAuthor(updateKey, meId), ]); let lastError = null; for (const pollCreatorJid of creatorCandidates) { for (const voterJid of voterCandidates) { try { const vote = decryptPollVote(pollUpdateMessage.vote, { pollCreatorJid, pollMsgId: creationKey.id, pollEncKey: secret, voterJid, }); return { pollUpdateMessageKey: updateKey, vote, senderTimestampMs: pollUpdateMessage.senderTimestampMs, }; } catch (err) { lastError = err; } } } if (lastError) throw lastError; return null; } export function addMentions(payload, mentions) { if (payload && Array.isArray(mentions) && mentions.length > 0) { payload.mentions = mentions; } return payload; } export function buildTextSendPayload(text, { replyTo, messageStore, mentions } = {}) { const content = addMentions({ text }, mentions); const options = {}; const quoted = messageStore?.get(replyTo); if (quoted?.key && quoted?.message) { // Baileys expects quoted messages as sendMessage options, not inside the // message content payload. Keeping this split avoids silently sending a // literal/ignored `quoted` field instead of a native WhatsApp reply. options.quoted = quoted; } return { content, options }; } export function buildLocationPayload({ latitude, longitude, name, address } = {}) { const lat = Number(latitude); const lon = Number(longitude); if (!Number.isFinite(lat) || !Number.isFinite(lon)) { throw new Error('latitude and longitude must be numbers'); } if (lat < -90 || lat > 90 || lon < -180 || lon > 180) { throw new Error('latitude/longitude out of range'); } const location = { degreesLatitude: lat, degreesLongitude: lon, }; if (name) location.name = String(name); if (address) location.address = String(address); return { location }; } function textFromQuotedMessage(quotedMessage) { const content = unwrapMessageEnvelopes(quotedMessage); if (!content) return ''; if (content.conversation) return content.conversation; if (content.extendedTextMessage?.text) return content.extendedTextMessage.text; if (content.imageMessage?.caption) return content.imageMessage.caption; if (content.videoMessage?.caption) return content.videoMessage.caption; if (content.documentMessage?.caption) return content.documentMessage.caption; if (content.documentMessage?.fileName) return `[Document: ${content.documentMessage.fileName}]`; if (content.locationMessage) return formatLocationText(content.locationMessage, false); if (content.contactMessage) return formatContactText(content.contactMessage); if (content.pollCreationMessage) return formatPollText(content.pollCreationMessage); return ''; } function mediaExtForMime(mime, fallback) { const normalized = String(mime || '').split(';', 1)[0].toLowerCase(); const extMap = { 'image/jpeg': '.jpg', 'image/png': '.png', 'image/webp': '.webp', 'image/gif': '.gif', 'video/mp4': '.mp4', 'video/quicktime': '.mov', 'video/x-matroska': '.mkv', 'audio/ogg': '.ogg', 'audio/mp4': '.m4a', 'audio/mpeg': '.mp3', 'application/pdf': '.pdf', }; return extMap[normalized] || fallback; } function defaultWriteMediaFile({ buffer, dir, prefix, ext, fileName }) { mkdirSync(dir, { recursive: true }); let safeName = fileName ? `_${path.basename(fileName).replace(/[^a-zA-Z0-9._-]/g, '_')}` : ''; if (safeName && ext && !path.extname(safeName)) { safeName = `${safeName}${ext}`; } const filePath = path.join(dir, `${prefix}_${randomBytes(6).toString('hex')}${safeName || ext}`); writeFileSync(filePath, buffer); return filePath; } function formatLocationText(location, isLive) { const name = location.name || location.address || ''; const lat = location.degreesLatitude ?? location.latitude; const lng = location.degreesLongitude ?? location.longitude; const kind = isLive ? 'Live location' : 'Location'; const coords = lat !== undefined && lng !== undefined ? `${lat},${lng}` : ''; return `[${kind}: ${[name, coords].filter(Boolean).join(' ')}]`; } function locationMetadata(location, isLive) { return { name: location.name || '', address: location.address || '', latitude: location.degreesLatitude ?? location.latitude ?? null, longitude: location.degreesLongitude ?? location.longitude ?? null, isLive, }; } function formatContactText(contact) { const name = contact.displayName || contact.vcard?.match(/FN:(.+)/)?.[1] || 'unknown'; const phone = contact.vcard?.match(/TEL[^:]*:(.+)/)?.[1] || ''; return `[Contact: ${[name, phone].filter(Boolean).join(' ')}]`; } function formatContactsText(contacts) { const names = contacts.map(c => c.displayName).filter(Boolean); return `[Contacts: ${names.join(', ') || contacts.length}]`; } function formatReactionText(reaction) { const emoji = reaction.text || ''; const target = reaction.key?.id || ''; return `[Reaction: ${emoji}${target ? ` to ${target}` : ''}]`; } function pollOptions(poll) { return (poll.options || []) .map(option => option.optionName || option.name) .filter(Boolean); } function formatPollText(poll) { const question = poll.name || poll.title || 'poll'; const options = pollOptions(poll); return `[Poll: ${question}${options.length ? ` Options: ${options.join(', ')}` : ''}]`; } function formatPollUpdateText(update) { const target = update.pollCreationMessageKey?.id || update.key?.id || ''; return `[Poll update${target ? `: ${target}` : ''}]`; } /** * Append a visible note for media that failed to download, so the agent knows * something was sent rather than silently losing the attachment. Returns * `content` unchanged when nothing failed. (Port of nanoclaw#2895.) */ export function appendMediaFailureNote(content, failures) { if (!failures || failures.length === 0) return content; const note = failures.map((t) => `[${t} could not be downloaded]`).join(' '); return content ? `${content}\n${note}` : note; } export async function extractBridgeEvent({ msg, chatId, senderId, senderNumber, botIds = [], isGroup = false, downloadMedia, writeMediaFile, cacheDirs = {}, lookupQuotedMedia, }) { const messageContent = getMessageContent(msg); const contextInfo = getContextInfo(messageContent); const mentionedIds = Array.from(new Set((contextInfo?.mentionedJid || []).map(normalizeWhatsAppId).filter(Boolean))); const quotedMessageId = contextInfo?.stanzaId || null; const quotedParticipant = normalizeWhatsAppId(contextInfo?.participant || '') || null; const quotedRemoteJid = normalizeWhatsAppId(contextInfo?.remoteJid || '') || null; const hasQuotedMessage = !!contextInfo?.quotedMessage; let quotedText = textFromQuotedMessage(contextInfo?.quotedMessage); let quotedMediaUrls = []; let quotedMediaType = ''; // contextInfo.quotedMessage only ever carries a thumbnail-sized stub for // media (or nothing for an uncaptioned attachment) — never a way to // re-fetch the original file. Resolve the quoted message's already-cached // media (downloaded when it first arrived) via lookupQuotedMedia so a // reply to an uncaptioned photo/video/document/voice note still gives the // agent the original file, not just silence. if (quotedMessageId && typeof lookupQuotedMedia === 'function') { const original = lookupQuotedMedia(quotedRemoteJid || chatId, quotedMessageId); if (original) { if (original.hasMedia && original.mediaUrls?.length) { quotedMediaUrls = original.mediaUrls; quotedMediaType = original.mediaType || ''; if (!quotedText) { quotedText = { image: 'sent an image', video: 'sent a video', gif: 'sent a GIF', audio: 'sent an audio message', ptt: 'sent a voice message', document: 'sent a document', sticker: 'sent a sticker', }[original.mediaType] || 'sent media'; } } else if (original.body && !quotedText) { quotedText = original.body; } } } let body = ''; let hasMedia = false; let mediaType = ''; let mime = ''; let fileName = ''; let nativeType = ''; const mediaUrls = []; const nativeMetadata = {}; const mediaFailures = []; const saveMedia = async ({ mediaMessage, dir, prefix, fallbackExt, fileName: name, type }) => { if (!downloadMedia) return; try { const buf = await downloadMedia(msg); const ext = mediaExtForMime(mediaMessage?.mimetype, fallbackExt); const writer = writeMediaFile || defaultWriteMediaFile; const saved = await writer({ buffer: buf, dir, prefix, ext, fileName: name }); if (saved) mediaUrls.push(saved); } catch (err) { // A failed CDN fetch (expired media URL, transient network error) must // never reject out of extractBridgeEvent — that would drop this message // AND every remaining message in the same upsert batch. Record the // failure so the agent is told media was sent instead of losing it // silently. (Port of nanoclaw#2895's never-silently-drop guarantee; the // reuploadRequest recovery half is already wired in bridge.js.) mediaFailures.push(type || 'media'); try { console.warn(`[bridge] failed to download inbound ${type || 'media'}:`, err?.message || err); } catch {} } }; if (messageContent.conversation) { body = messageContent.conversation; nativeType = 'conversation'; } else if (messageContent.extendedTextMessage?.text) { body = messageContent.extendedTextMessage.text; nativeType = 'extendedTextMessage'; } else if (messageContent.imageMessage) { const item = messageContent.imageMessage; body = item.caption || ''; hasMedia = true; mediaType = 'image'; nativeType = 'imageMessage'; mime = item.mimetype || 'image/jpeg'; await saveMedia({ mediaMessage: item, dir: cacheDirs.image, prefix: 'img', fallbackExt: '.jpg', type: 'image' }); } else if (messageContent.videoMessage) { const item = messageContent.videoMessage; body = item.caption || ''; hasMedia = true; mediaType = item.gifPlayback ? 'gif' : 'video'; nativeType = 'videoMessage'; mime = item.mimetype || 'video/mp4'; nativeMetadata.video = { gifPlayback: !!item.gifPlayback }; await saveMedia({ mediaMessage: item, dir: cacheDirs.document, prefix: 'vid', fallbackExt: '.mp4', type: mediaType }); } else if (messageContent.audioMessage || messageContent.pttMessage) { const item = messageContent.pttMessage || messageContent.audioMessage; hasMedia = true; mediaType = item.ptt || messageContent.pttMessage ? 'ptt' : 'audio'; nativeType = messageContent.pttMessage ? 'pttMessage' : 'audioMessage'; mime = item.mimetype || 'audio/ogg'; nativeMetadata.audio = { ptt: mediaType === 'ptt' }; await saveMedia({ mediaMessage: item, dir: cacheDirs.audio, prefix: 'aud', fallbackExt: '.ogg', type: 'audio' }); } else if (messageContent.documentMessage) { const item = messageContent.documentMessage; body = item.caption || ''; hasMedia = true; mediaType = 'document'; nativeType = 'documentMessage'; mime = item.mimetype || 'application/octet-stream'; fileName = item.fileName || 'document'; await saveMedia({ mediaMessage: item, dir: cacheDirs.document, prefix: 'doc', fallbackExt: '.bin', fileName, type: 'document' }); } else if (messageContent.stickerMessage) { hasMedia = true; mediaType = 'sticker'; nativeType = 'stickerMessage'; mime = messageContent.stickerMessage.mimetype || 'image/webp'; body = '[Sticker]'; nativeMetadata.sticker = { animated: !!messageContent.stickerMessage.isAnimated, mimetype: mime, }; await saveMedia({ mediaMessage: messageContent.stickerMessage, dir: cacheDirs.image, prefix: 'sticker', fallbackExt: '.webp', type: 'sticker' }); } else if (messageContent.locationMessage || messageContent.liveLocationMessage) { const isLive = !!messageContent.liveLocationMessage; const item = messageContent.liveLocationMessage || messageContent.locationMessage; mediaType = isLive ? 'live_location' : 'location'; nativeType = isLive ? 'liveLocationMessage' : 'locationMessage'; body = formatLocationText(item, isLive); nativeMetadata.location = locationMetadata(item, isLive); } else if (messageContent.contactMessage) { mediaType = 'contact'; nativeType = 'contactMessage'; body = formatContactText(messageContent.contactMessage); nativeMetadata.contact = { displayName: messageContent.contactMessage.displayName || '', vcard: messageContent.contactMessage.vcard || '', }; } else if (messageContent.contactsArrayMessage) { const contacts = messageContent.contactsArrayMessage.contacts || []; mediaType = 'contacts'; nativeType = 'contactsArrayMessage'; body = formatContactsText(contacts); nativeMetadata.contacts = contacts.map(contact => ({ displayName: contact.displayName || '', vcard: contact.vcard || '', })); } else if (messageContent.reactionMessage) { mediaType = 'reaction'; nativeType = 'reactionMessage'; body = formatReactionText(messageContent.reactionMessage); nativeMetadata.reaction = { text: messageContent.reactionMessage.text || '', messageId: messageContent.reactionMessage.key?.id || '', remoteJid: normalizeWhatsAppId(messageContent.reactionMessage.key?.remoteJid || ''), participant: normalizeWhatsAppId(messageContent.reactionMessage.key?.participant || ''), }; } else if (messageContent.pollCreationMessage || messageContent.pollCreationMessageV2 || messageContent.pollCreationMessageV3) { const item = messageContent.pollCreationMessage || messageContent.pollCreationMessageV2 || messageContent.pollCreationMessageV3; mediaType = 'poll'; nativeType = messageContent.pollCreationMessage ? 'pollCreationMessage' : messageContent.pollCreationMessageV2 ? 'pollCreationMessageV2' : 'pollCreationMessageV3'; body = formatPollText(item); nativeMetadata.poll = { question: item.name || item.title || '', options: pollOptions(item), selectableCount: item.selectableOptionsCount || item.selectableCount || 1, }; } else if (messageContent.pollUpdateMessage) { mediaType = 'poll_update'; nativeType = 'pollUpdateMessage'; body = formatPollUpdateText(messageContent.pollUpdateMessage); nativeMetadata.pollUpdate = messageContent.pollUpdateMessage; } // Surface failed downloads to the agent instead of silently losing the // attachment. Applied before the generic "[ received]" fallback so an // uncaptioned message whose download failed reads "[image could not be // downloaded]" rather than claiming the media arrived. body = appendMediaFailureNote(body, mediaFailures); if (hasMedia && !body) { body = `[${mediaType} received]`; } return { messageId: msg.key.id, chatId, senderId, senderName: msg.pushName || senderNumber, chatName: isGroup ? (chatId.split('@')[0]) : (msg.pushName || senderNumber), isGroup, body, hasMedia, mediaType, mime, fileName, nativeType, nativeMetadata, mediaUrls, mentionedIds, quotedMessageId, quotedParticipant, quotedRemoteJid, quotedText, quotedMediaUrls, quotedMediaType, hasQuotedMessage, botIds, readReceiptKey: { remoteJid: msg.key.remoteJid || chatId, id: msg.key.id, participant: msg.key.participant || senderId, fromMe: Boolean(msg.key.fromMe), }, timestamp: msg.messageTimestamp, }; } export function inferMediaType(ext) { if (['jpg', 'jpeg', 'png', 'webp', 'gif'].includes(ext)) return 'image'; if (['mp4', 'mov', 'avi', 'mkv', '3gp'].includes(ext)) return 'video'; if (['ogg', 'opus', 'mp3', 'wav', 'm4a'].includes(ext)) return 'audio'; return 'document'; } export function inboundReadReceiptKeys({ key, enabled }) { if (!enabled || !key || key.fromMe || !key.id || !key.remoteJid) return []; // Preserve participant for group messages: Baileys needs the original key. return [key]; } // proto.WebMessageInfo.Status values (Baileys). PENDING is our own local state, never a receipt. const DELIVERY_STATUS_NAMES = { 0: 'error', 2: 'server_ack', 3: 'delivered', 4: 'read', 5: 'played' }; const RECEIPT_TIMESTAMP_STATUS = [ ['playedTimestamp', 'played'], ['readTimestamp', 'read'], ['receiptTimestamp', 'delivered'], ]; /** * Delivery/read status of a message Hermes sent, as a queue event for the adapter to log. * `messages.update` carries `update.status` for 1:1 chats; `message-receipt.update` carries a * per-recipient `receipt` for groups. Returns null for anything that is not a status change of * one of our own sends (`isOwnSend(id)`), so human messages on the linked phone are never logged. */ export function deliveryStatusEvent({ key, update, receipt, isOwnSend }) { if (!key?.fromMe || !key.id || !isOwnSend(key.id)) return null; let status; let at; let recipientId = ''; if (receipt) { const hit = RECEIPT_TIMESTAMP_STATUS.find(([field]) => receipt[field]); if (!hit) return null; [, status] = hit; at = Number(receipt[hit[0]]) || 0; recipientId = normalizeWhatsAppId(receipt.userJid || ''); } else { status = DELIVERY_STATUS_NAMES[update?.status]; if (!status) return null; at = Number(update.messageTimestamp) || 0; } const event = { event: 'delivery_status', messageId: key.id, chatId: normalizeWhatsAppId(key.remoteJid || ''), status, timestamp: at || Math.floor(Date.now() / 1000), }; if (recipientId) event.recipientId = recipientId; const error = status === 'error' ? update?.messageStubParameters?.[0] : undefined; if (error) event.error = String(error); return event; } export function mediaPayloadForFile({ buffer, filePath, mediaType, caption, fileName }) { const ext = filePath.toLowerCase().split('.').pop(); const type = mediaType || inferMediaType(ext); if (type === 'image' && ext === 'gif') { // Pure helper fallback: do not lie and label raw GIF bytes as mp4. // The live bridge tries ffmpeg conversion to WhatsApp gifPlayback video // before it falls back to this regular image payload. return { image: buffer, caption: caption || undefined, mimetype: MIME_MAP[ext] || 'image/gif' }; } switch (type) { case 'image': return { image: buffer, caption: caption || undefined, mimetype: MIME_MAP[ext] || 'image/jpeg' }; case 'video': return { video: buffer, caption: caption || undefined, mimetype: MIME_MAP[ext] || 'video/mp4' }; case 'document': return { document: buffer, fileName: fileName || path.basename(filePath), caption: caption || undefined, mimetype: MIME_MAP[ext] || 'application/octet-stream', }; default: return null; } } export function buildPollPayload({ question, options, selectableCount = 1 }) { const cleanQuestion = String(question || '').trim(); const cleanOptions = (options || []).map(option => String(option || '').trim()).filter(Boolean); if (!cleanQuestion) throw new Error('question is required'); if (cleanOptions.length < 2) throw new Error('at least two poll options are required'); if (cleanOptions.length > 12) throw new Error('at most 12 poll options are supported'); const count = Math.max(1, Math.min(Number(selectableCount) || 1, cleanOptions.length)); return { poll: { name: cleanQuestion, values: cleanOptions, selectableCount: count, messageSecret: randomBytes(32), }, }; } export function pollCreationMessageFromPayload(payload) { const poll = payload?.poll; if (!poll) return null; const values = Array.isArray(poll.values) ? poll.values : []; const options = values.map(value => String(value || '').trim()).filter(Boolean); if (!poll.name || options.length < 2) return null; const selectableOptionsCount = Math.max(1, Math.min(Number(poll.selectableCount) || 1, options.length)); const message = {}; if (poll.messageSecret) { message.messageContextInfo = { messageSecret: poll.messageSecret }; } message[selectableOptionsCount === 1 ? 'pollCreationMessageV3' : 'pollCreationMessage'] = { name: String(poll.name), options: options.map(optionName => ({ optionName })), selectableOptionsCount, }; return message; } /** * Reconnect scheduling guard. startSocket() awaits network I/O before it * creates a socket or registers event handlers, so a bare * `setTimeout(startSocket, ...)` has two unrecoverable failure modes: a * rejection is unhandled (crashes the process on modern Node), and a hang * leaves the bridge permanently disconnected with nothing left to retry. * Every (re)connect must go through the scheduler this returns. */ export function createReconnectScheduler(startFn, { retryDelayMs = 5000, log = console.log, setTimeoutFn = setTimeout, } = {}) { function scheduleReconnect(delayMs) { setTimeoutFn(() => { Promise.resolve() .then(startFn) .catch((err) => { log(`⚠️ Reconnect failed (${err?.message || err}). Retrying in ${Math.round(retryDelayMs / 1000)}s...`); scheduleReconnect(retryDelayMs); }); }, delayMs); } return scheduleReconnect; } /** * Version resolution guard. fetchLatestBaileysVersion() is a plain fetch to * raw.githubusercontent.com with no AbortSignal; a stalled connection can * pend forever and wedge the reconnect path (the scheduler above cannot * retry past an await that never settles). Bound the fetch and fall back to * the last known-good version, or the Baileys default before first success. */ export function createVersionResolver(fetchVersionFn, { timeoutMs = 15000, log = console.log, } = {}) { let cachedVersion = null; return async function resolveVersion() { let timer = null; try { const { version } = await Promise.race([ fetchVersionFn(), new Promise((_, reject) => { timer = setTimeout(() => reject(new Error('version fetch timed out')), timeoutMs); }), ]); cachedVersion = version; } catch (err) { log(`⚠️ Baileys version fetch failed (${err?.message || err}); using ${cachedVersion ? 'cached version' : 'library default'}.`); } finally { if (timer) clearTimeout(timer); } return cachedVersion; }; } const pad = (value, width = 2) => String(value).padStart(width, '0'); /** `2026-09-28 13:18:46,062` in local time: the asctime shape every file in logs/ uses. */ export function formatLogStamp(date) { const day = `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`; const time = `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`; return `${day} ${time},${pad(date.getMilliseconds(), 3)}`; } /** * Stamp every console.log/warn/error line. The adapter captures stdout/stderr * verbatim into bridge.log, which otherwise cannot be sequenced (#97021). */ export function installConsoleStamps(target = console) { for (const method of ['log', 'warn', 'error']) { const original = target[method].bind(target); target[method] = (...args) => { const text = format(...args); original('%s', text ? `${formatLogStamp(new Date())} ${text}` : text); }; } } /** Machine-read JSON event lines bypass the console stamp so line parsers see bare JSON. */ export function writeJsonLine(payload, stream = process.stdout) { stream.write(`${JSON.stringify(payload)}\n`); }