@charape/baileys 1.0.9 → 1.0.10

package/lib/Socket/socket.js

@@ -406,6 +406,7 @@ export const makeSocket = (config) => {
     let lastDateRecv;
     let epoch = 1;
     let keepAliveReq;
+    let missedKeepAlives = 0;
     let qrTimer;
     let closed = false;
     const socketEndHandlers = [];
@@ -610,8 +611,11 @@ export const makeSocket = (config) => {
         }
         closed = true;
         logger.info({ trace: error?.stack }, error ? 'connection errored' : 'connection closed');
+        missedKeepAlives = 0;
         clearInterval(keepAliveReq);
+        keepAliveReq = undefined;
         clearTimeout(qrTimer);
+        qrTimer = undefined;
         ws.removeAllListeners('close');
         ws.removeAllListeners('open');
         ws.removeAllListeners('message');
@@ -661,20 +665,13 @@ export const makeSocket = (config) => {
             ws.off('error', onClose);
         });
     };
-    const startKeepAliveRequest = () => (keepAliveReq = setInterval(() => {
-        if (!lastDateRecv) {
-            lastDateRecv = new Date();
-        }
-        const diff = Date.now() - lastDateRecv.getTime();
-        /*
-            check if it's been a suspicious amount of time since the server responded with our last seen
-            it could be that the network is down
-        */
-        if (diff > keepAliveIntervalMs + 5000) {
-            void end(new Boom('Connection was lost', { statusCode: DisconnectReason.connectionLost }));
-        }
-        else if (ws.isOpen) {
-            // if its all good, send a keep alive request
+    const startKeepAliveRequest = () => {
+        missedKeepAlives = 0;
+        const sendKeepAlivePing = () => {
+            if (!ws.isOpen) {
+                logger.warn('keep alive called when WS not open');
+                return;
+            }
             query({
                 tag: 'iq',
                 attrs: {
@@ -684,14 +681,38 @@ export const makeSocket = (config) => {
                     xmlns: 'w:p'
                 },
                 content: [{ tag: 'ping', attrs: {} }]
+            }).then(() => {
+                lastDateRecv = new Date();
+                missedKeepAlives = 0;
             }).catch(err => {
-                logger.error({ trace: err.stack }, 'error in sending keep alive');
+                logger.error({ trace: err?.stack }, 'error in sending keep alive');
             });
-        }
-        else {
-            logger.warn('keep alive called when WS not open');
-        }
-    }, keepAliveIntervalMs));
+        };
+        keepAliveReq = setInterval(() => {
+            if (!lastDateRecv) {
+                lastDateRecv = new Date();
+            }
+            const diff = Date.now() - lastDateRecv.getTime();
+            const maxGraceDiff = Math.max(keepAliveIntervalMs * 2.5, keepAliveIntervalMs + 20000);
+            if (diff > keepAliveIntervalMs + 5000) {
+                missedKeepAlives++;
+                if (missedKeepAlives >= 2 || diff > maxGraceDiff) {
+                    void end(new Boom('Connection was lost', { statusCode: DisconnectReason.connectionLost }));
+                } else {
+                    logger.debug({ diff, missedKeepAlives }, 'keep-alive latency tolerance, sending retry ping');
+                    sendKeepAlivePing();
+                }
+            }
+            else if (ws.isOpen) {
+                missedKeepAlives = 0;
+                sendKeepAlivePing();
+            }
+            else {
+                logger.warn('keep alive called when WS not open');
+            }
+        }, keepAliveIntervalMs);
+        return keepAliveReq;
+    };
     /** i have no idea why this exists. pls enlighten me */
     const sendPassiveIq = (tag) => query({
         tag: 'iq',

package/lib/Store/make-cache-manager-store.js

@@ -1,6 +1,24 @@
 import { createRequire } from "module";
-const _require = typeof require !== "undefined" ? require : createRequire(import.meta.url);
-const cacheManager = _require("cache-manager");
+import { join } from "path";
+import { pathToFileURL } from "url";
+
+let cacheManager;
+const loadCacheManager = async () => {
+    if (cacheManager) return cacheManager;
+    if (typeof require === "function") {
+        cacheManager = require("cache-manager");
+        return cacheManager;
+    }
+    try {
+        const mod = await import("cache-manager");
+        cacheManager = mod?.default || mod;
+        return cacheManager;
+    } catch {
+        const _require = createRequire(pathToFileURL(join(process.cwd(), "package.json")).href);
+        cacheManager = _require("cache-manager");
+        return cacheManager;
+    }
+};
 
 import * as WAProto_1 from "../../WAProto/index.js";
 import * as Utils_1 from "../Utils/index.js";
@@ -8,7 +26,8 @@ import logger from "../Utils/logger.js";
 
 export default async function makeCacheManagerAuthState(store, sessionKey) {
     const defaultKey = (file) => `${sessionKey}:${file}`;
-    const databaseConn = await cacheManager.caching(store);
+    const cm = await loadCacheManager();
+    const databaseConn = await cm.caching(store);
 
     const writeData = async (file, data) => {
         let ttl = undefined;

package/lib/Utils/charape-runtime.js

@@ -0,0 +1,230 @@
+import { jidNormalizedUser, isLidUser, isHostedLidUser, isPnUser, isHostedPnUser } from '../WABinary/index.js';
+
+const ANSI = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    cyan: '\x1b[36m',
+    blue: '\x1b[34m',
+    green: '\x1b[32m',
+    magenta: '\x1b[35m',
+    yellow: '\x1b[33m',
+    white: '\x1b[37m'
+};
+
+/**
+ * Insert or refresh an entry in a Map while enforcing an upper bound (FIFO/LRU eviction).
+ */
+export const setBoundedMapEntry = (map, key, value, maxEntries = 2000) => {
+    if (!map || key === undefined || key === null) return map;
+    if (map.has(key)) {
+        map.delete(key);
+    }
+    map.set(key, value);
+    while (map.size > maxEntries) {
+        const oldestKey = map.keys().next().value;
+        if (oldestKey === undefined) break;
+        map.delete(oldestKey);
+    }
+    return map;
+};
+
+/**
+ * Insert or refresh an entry in a Set while enforcing an upper bound.
+ */
+export const addBoundedSetEntry = (set, value, maxEntries = 2000) => {
+    if (!set || value === undefined || value === null) return set;
+    if (set.has(value)) {
+        set.delete(value);
+    }
+    set.add(value);
+    while (set.size > maxEntries) {
+        const oldestValue = set.values().next().value;
+        if (oldestValue === undefined) break;
+        set.delete(oldestValue);
+    }
+    return set;
+};
+
+/**
+ * Resolve PN (@s.whatsapp.net) or LID (@lid) JID safely through lidMapping without throwing.
+ */
+export const resolveJidWithMapping = async (jid, lidMapping, target = 'pn') => {
+    if (!jid || typeof jid !== 'string') return jid;
+    const normalized = jidNormalizedUser(jid);
+    if (!lidMapping) return normalized;
+
+    try {
+        if (target === 'pn') {
+            if (isPnUser(normalized) || isHostedPnUser(normalized)) return normalized;
+            if ((isLidUser(normalized) || isHostedLidUser(normalized)) && typeof lidMapping.getPNForLID === 'function') {
+                const pn = await lidMapping.getPNForLID(normalized);
+                return pn ? jidNormalizedUser(pn) : normalized;
+            }
+        } else if (target === 'lid') {
+            if (isLidUser(normalized) || isHostedLidUser(normalized)) return normalized;
+            if ((isPnUser(normalized) || isHostedPnUser(normalized)) && typeof lidMapping.getLIDForPN === 'function') {
+                const lid = await lidMapping.getLIDForPN(normalized);
+                return lid ? jidNormalizedUser(lid) : normalized;
+            }
+        }
+    } catch {
+        // Fallback silently to normalized JID so caller handlers never crash
+    }
+    return normalized;
+};
+
+const SKIPPED_LOG_CONTENT_TYPES = new Set([
+    'protocolMessage',
+    'senderKeyDistributionMessage',
+    'fastRatchetSenderKeyDistributionMessage',
+    'messageContextInfo',
+    'historySyncNotification',
+    'initialSecurityNotificationSettingSync',
+    'appStateSyncKeyShare',
+    'appStateFatalExceptionNotification'
+]);
+
+const WRAPPER_KEYS = [
+    'ephemeralMessage',
+    'viewOnceMessage',
+    'viewOnceMessageV2',
+    'viewOnceMessageV2Extension',
+    'documentWithCaptionMessage',
+    'editedMessage'
+];
+
+const unwrapMessageShape = (message) => {
+    let curr = message;
+    for (let depth = 0; depth < 4 && curr && typeof curr === 'object'; depth++) {
+        let unwrapped = false;
+        for (const key of WRAPPER_KEYS) {
+            if (curr[key]?.message) {
+                curr = curr[key].message;
+                unwrapped = true;
+                break;
+            }
+        }
+        if (!unwrapped) break;
+    }
+    return curr;
+};
+
+const detectDisplayTypeAndPreview = (message) => {
+    const content = unwrapMessageShape(message);
+    if (!content || typeof content !== 'object') return null;
+
+    const keys = Object.keys(content).filter(k => k !== 'messageContextInfo' && content[k] !== undefined && content[k] !== null);
+    if (keys.length === 0) return null;
+
+    const primaryKey = keys.find(k => !SKIPPED_LOG_CONTENT_TYPES.has(k)) || keys[0];
+    if (SKIPPED_LOG_CONTENT_TYPES.has(primaryKey)) return null;
+
+    const val = content[primaryKey];
+    let textPreview = '';
+    if (primaryKey === 'conversation' && typeof val === 'string') {
+        textPreview = val;
+    } else if (val && typeof val === 'object') {
+        textPreview = val.text || val.caption || val.fileName || val.title || val.body?.text || val.header?.title || val.name || '';
+    }
+
+    const cleanPreview = String(textPreview || '').replace(/[\r\n\t]+/g, ' ').trim();
+    const byteSize = cleanPreview ? Buffer.byteLength(cleanPreview, 'utf8') : 0;
+    const typeLabel = primaryKey
+        .replace(/Message$/i, '')
+        .replace(/([A-Z])/g, ' $1')
+        .replace(/^./, s => s.toUpperCase())
+        .trim();
+
+    return {
+        rawType: primaryKey,
+        typeLabel: typeLabel || 'Message',
+        preview: cleanPreview.length > 48 ? cleanPreview.slice(0, 45) + '...' : cleanPreview,
+        byteSize
+    };
+};
+
+let totalLoggedMessages = 0;
+let burstWindowStart = 0;
+let burstCountInWindow = 0;
+const printedLogIds = new Set();
+const MAX_PRINTS_PER_SECOND = 25;
+
+/**
+ * Format an iconic CHARAPE terminal chat card inspired by the clean MESSAGE INFO layout.
+ */
+export const formatCharapeChatLog = (direction = 'IN', msg = {}, count = totalLoggedMessages) => {
+    const info = detectDisplayTypeAndPreview(msg?.message);
+    if (!info) return null;
+
+    const isOut = String(direction).toUpperCase().startsWith('OUT');
+    const key = msg?.key || {};
+    const remoteJid = key.remoteJid || '-';
+    const senderRaw = key.participantAlt || key.remoteJidAlt || key.participant || key.remoteJid || '-';
+    const senderId = String(senderRaw).split('@')[0].split(':')[0] || '-';
+    const senderName = msg.pushName || (isOut ? 'CHARAPE BOT' : senderId);
+    const tsRaw = Number(msg.messageTimestamp || 0);
+    const tsDate = tsRaw > 0 ? new Date(tsRaw > 1e12 ? tsRaw : tsRaw * 1000) : new Date();
+    const sentTime = Number.isNaN(tsDate.getTime()) ? new Date().toLocaleString() : tsDate.toLocaleString();
+    const sizeInfo = info.preview ? `${info.byteSize} bytes (${info.preview})` : `${info.typeLabel}`;
+
+    const border = `${ANSI.blue}════════════════════════════════════════════════════${ANSI.reset}`;
+    const badgeColor = isOut ? ANSI.magenta : ANSI.green;
+    const dirLabel = isOut ? 'OUTGOING CHAT' : 'INCOMING CHAT';
+
+    return [
+        border,
+        ` ${badgeColor}${ANSI.bold}⚡ CHARAPE${ANSI.reset} ${ANSI.dim}•${ANSI.reset} ${ANSI.magenta}${ANSI.bold}${dirLabel}${ANSI.reset}`,
+        border,
+        `  ${ANSI.cyan}📌 Message Type ${ANSI.reset}: ${ANSI.white}${info.typeLabel}${ANSI.reset}`,
+        `  ${ANSI.cyan}🆔 Message ID   ${ANSI.reset}: ${ANSI.white}${key.id || '-'}${ANSI.reset}`,
+        `  ${ANSI.cyan}⏰ Sent Time    ${ANSI.reset}: ${ANSI.white}${sentTime}${ANSI.reset}`,
+        `  ${ANSI.cyan}📁 Content/Size ${ANSI.reset}: ${ANSI.white}${sizeInfo}${ANSI.reset}`,
+        `  ${ANSI.cyan}👤 Sender ID    ${ANSI.reset}: ${ANSI.white}${senderId}${ANSI.reset}`,
+        `  ${ANSI.cyan}🎭 Sender Name  ${ANSI.reset}: ${ANSI.white}${senderName}${ANSI.reset}`,
+        `  ${ANSI.cyan}💬 Chat ID      ${ANSI.reset}: ${ANSI.white}${remoteJid}${ANSI.reset}`,
+        `  ${ANSI.cyan}📊 Total Logs   ${ANSI.reset}: ${ANSI.yellow}${count}${ANSI.reset}`,
+        border
+    ].join('\n');
+};
+
+/**
+ * Safely print iconic CHARAPE terminal chat card without blocking or flooding stdout.
+ */
+export const printCharapeChatLog = (direction = 'IN', msg = {}, options = {}) => {
+    try {
+        if (options.enabled === false) return false;
+        if (!options.ignoreEnvSilent && process.env.CHARAPE_SILENT === 'true') return false;
+        if (!msg || typeof msg !== 'object' || !msg.message) return false;
+
+        const dir = String(direction || 'IN').toUpperCase().startsWith('OUT') ? 'OUT' : 'IN';
+        const msgId = msg.key?.id;
+        if (msgId && !options.force) {
+            const dedupeKey = `${dir}:${msgId}`;
+            if (printedLogIds.has(dedupeKey)) return false;
+            addBoundedSetEntry(printedLogIds, dedupeKey, 600);
+        }
+
+        const now = Date.now();
+        if (now - burstWindowStart >= 1000) {
+            burstWindowStart = now;
+            burstCountInWindow = 0;
+        }
+        if (!options.force && burstCountInWindow >= MAX_PRINTS_PER_SECOND) {
+            return false;
+        }
+
+        const nextCount = totalLoggedMessages + 1;
+        const formatted = formatCharapeChatLog(dir, msg, nextCount);
+        if (!formatted) return false;
+
+        totalLoggedMessages = nextCount;
+        burstCountInWindow++;
+
+        const writer = typeof options.writer === 'function' ? options.writer : console.log;
+        writer(formatted);
+        return true;
+    } catch {
+        return false;
+    }
+};

package/lib/Utils/decode-wa-message.js

@@ -4,6 +4,7 @@ import { areJidsSameUser, isHostedLidUser, isHostedPnUser, isJidBroadcast, isJid
 //	transferDevice
  } from '../WABinary/index.js';
 import { unpadRandomMax16 } from './generics.js';
+import { setBoundedMapEntry } from './charape-runtime.js';
 export const getDecryptionJid = async (sender, repository) => {
     if (isLidUser(sender) || isHostedLidUser(sender)) {
         return sender;
@@ -97,6 +98,8 @@ const MAX_SECRETS_PER_CHAT = 20
 // Module-level map: outgoing @bot message ID → messageSecret
 // Populated when we receive the outgoing pkmsg/msg to @bot (which contains messageContextInfo.messageSecret)
 // Consumed when the msmsg response from @bot arrives and needs decryption
+const MAX_BOT_MESSAGE_SECRETS = 5000
+const MAX_BOT_RECENT_CHATS = 1000
 const botMessageSecrets = new Map()
 const botRecentSecretsByChat = new Map()
 const pushRecentChatSecret = (chatJid, id, secretBuf) => {
@@ -107,7 +110,7 @@ const pushRecentChatSecret = (chatJid, id, secretBuf) => {
 	if (filtered.length > MAX_SECRETS_PER_CHAT) {
 		filtered.length = MAX_SECRETS_PER_CHAT
 	}
-	botRecentSecretsByChat.set(chatJid, filtered)
+	setBoundedMapEntry(botRecentSecretsByChat, chatJid, filtered, MAX_BOT_RECENT_CHATS)
 }
 export const setBotMessageSecret = (id, secret, chatJid) => {
 	if (!id || !secret) return
@@ -121,7 +124,7 @@ export const setBotMessageSecret = (id, secret, chatJid) => {
 	} else {
 		return
 	}
-	botMessageSecrets.set(id, buf)
+	setBoundedMapEntry(botMessageSecrets, id, buf, MAX_BOT_MESSAGE_SECRETS)
 	if (chatJid) {
 		pushRecentChatSecret(chatJid, id, buf)
 	}

package/lib/Utils/index.js

@@ -23,4 +23,5 @@ export * from './stanza-ack.js';
 export * from './message-composer.js';
 export * from './clean-session.js';
 export * from './use-single-file-auth-state.js';
+export * from './charape-runtime.js';
 //# sourceMappingURL=index.js.map