miaw-core 1.13.1 → 1.13.2

package/dist/client/MiawClient.js

@@ -9,6 +9,7 @@ import { AuthHandler } from "../handlers/AuthHandler.js";
 import { MessageHandler } from "../handlers/MessageHandler.js";
 import { TIMEOUTS, THRESHOLDS } from "../constants/timeouts.js";
 import { CACHE_CONFIG } from "../constants/cache.js";
+import { LAZY_HISTORY_SYNC_TYPES } from "../constants/history-sync.js";
 import { validatePhoneNumber, validateJID, validateMessageText, validateGroupName, validatePhoneNumbers, } from "../utils/validation.js";
 import { createProxyAgents, maskProxyUrl, validateProxyConfig, } from "../utils/proxy-agent.js";
 /**
@@ -172,6 +173,20 @@ export class MiawClient extends EventEmitter {
     contactsStore = new Map();
     chatsStore = new Map();
     messagesStore = new Map();
+    // Message ids per chat, so storeMessage() dedups in O(1) instead of scanning
+    // the bucket. Kept in step with every messagesStore mutation.
+    messageIdIndex = new Map();
+    // Coalesced disk persistence: stores are marked dirty and written together
+    // after a quiet period (see schedulePersist).
+    dirtyStores = new Set();
+    persistTimer = null;
+    persistFirstDirtyAt = 0;
+    // Set once the session files are wiped (logout / unlink), so a late store
+    // update cannot recreate the deleted session dir. Cleared by connect().
+    persistSuspended = false;
+    // syncFullHistory as captured by the current connect(). enableSync() /
+    // disableSync() take effect on the next connection, not mid-sync.
+    activeSyncFullHistory = false;
     labelsStore = new Map();
     // Store label-chat associations (labelId -> Set of chatJids)
     labelChatsStore = new Map();
@@ -201,7 +216,10 @@ export class MiawClient extends EventEmitter {
             qrGracePeriod: options.qrGracePeriod || TIMEOUTS.QR_GRACE_PERIOD,
             qrScanTimeout: options.qrScanTimeout || TIMEOUTS.QR_SCAN_TIMEOUT,
             connectionTimeout: options.connectionTimeout || TIMEOUTS.CONNECTION_TIMEOUT,
-            syncFullHistory: options.syncFullHistory !== false,
+            // Default OFF: a fresh pair would otherwise pull the phone's entire
+            // history up front. Only the bootstrap is ingested; older history is
+            // fetched on demand via loadMoreMessages().
+            syncFullHistory: options.syncFullHistory === true,
             // Default OFF. The whole point of the existing gate is that a bot must
             // not react to its own sends, so opting in has to be deliberate.
             emitOwnMessages: options.emitOwnMessages === true,
@@ -246,6 +264,10 @@ export class MiawClient extends EventEmitter {
             // Load persisted stores from disk before connecting
             // This ensures data is available even if Baileys history sync doesn't fire
             // (Known Baileys v7 issue: history sync notification may be received but never processed)
+            // Flush first: on a reconnect, writes still in the debounce window are
+            // newer than the files and would otherwise be replaced by them.
+            this.flushPersist();
+            this.persistSuspended = false;
             this.loadLabelsFromFile();
             this.loadContactsFromFile();
             this.loadLidMappingsFromFile(); // Load LID mappings BEFORE chats for resolution
@@ -280,6 +302,7 @@ export class MiawClient extends EventEmitter {
             this.activeProxy = usingCustomAgent ? undefined : this.describeConfiguredProxy();
             this.activeProxyKey = usingCustomAgent ? undefined : this.configuredProxyUrl();
             // Create socket
+            this.activeSyncFullHistory = this.options.syncFullHistory;
             const debugMode = this.options.debug;
             const logger = this.logger;
             this.socket = makeWASocket({
@@ -299,15 +322,15 @@ export class MiawClient extends EventEmitter {
                 // Auto-recreate signal sessions on retry and migrate PN<->LID sessions
                 // (Baileys rc13 default; set explicitly to document the LID reliance).
                 enableAutoSessionRecreation: true,
-                // Enable full history sync to populate stores (controlled by syncFullHistory option)
-                syncFullHistory: this.options.syncFullHistory,
+                // Ask the phone for its full history only when opted in
+                syncFullHistory: this.activeSyncFullHistory,
                 fireInitQueries: true,
-                // Debug callback to see if history sync notifications are received
                 shouldSyncHistoryMessage: (msg) => {
+                    const accept = this.shouldProcessHistorySync(msg.syncType);
                     if (debugMode) {
-                        logger.debug(`[shouldSyncHistoryMessage] syncType: ${msg.syncType}`);
+                        logger.debug(`[shouldSyncHistoryMessage] syncType: ${msg.syncType} -> ${accept ? "accept" : "skip"}`);
                     }
-                    return this.options.syncFullHistory;
+                    return accept;
                 },
                 // Proxy support: agent for WebSocket, fetchAgent for media HTTP requests
                 ...(proxyAgents?.wsAgent ? { agent: proxyAgents.wsAgent } : {}),
@@ -694,9 +717,10 @@ export class MiawClient extends EventEmitter {
             this.updateChatsStore(chats);
         });
         // History sync - populates contacts, chats, and messages from history
-        this.socket.ev.on("messaging-history.set", ({ chats, contacts, messages, lidPnMappings, isLatest, peerDataRequestSessionId }) => {
+        this.socket.ev.on("messaging-history.set", ({ chats, contacts, messages, lidPnMappings, isLatest, peerDataRequestSessionId, syncType }) => {
             if (this.options.debug) {
                 this.logger.debug("\n========== MESSAGING HISTORY SYNC ==========");
+                this.logger.debug(`Sync type: ${syncType ?? "unknown"}`);
                 this.logger.debug(`Contacts: ${contacts.length}, Chats: ${chats.length}, Messages: ${messages.length}, LID maps: ${lidPnMappings?.length ?? 0}`);
                 this.logger.debug(`Is Latest: ${isLatest}, SessionId: ${peerDataRequestSessionId || 'none'}`);
                 this.logger.debug("============================================\n");
@@ -916,9 +940,9 @@ export class MiawClient extends EventEmitter {
                     };
                     this.labelsStore.set(label.id, labelData);
                 }
-                // Persist labels to disk after every update
+                // Persist labels to disk
                 // This ensures labels survive reconnections where resyncAppState returns only patches
-                this.saveLabelsToFile();
+                this.schedulePersist("labels");
             }
         });
         // Handle label-chat associations
@@ -1053,7 +1077,7 @@ export class MiawClient extends EventEmitter {
         }
         // Persist to disk if this is a new mapping
         if (isNew) {
-            this.saveLidMappingsToFile();
+            this.schedulePersist("lid");
         }
     }
     /**
@@ -1366,10 +1390,10 @@ export class MiawClient extends EventEmitter {
                 this.contactsStore.set(contact.id, contactInfo);
             }
         }
-        // Persist contacts to disk after every update
+        // Persist contacts to disk
         // This ensures contacts survive reconnections where history sync may not fire
         if (contacts.length > 0) {
-            this.saveContactsToFile();
+            this.schedulePersist("contacts");
         }
     }
     /**
@@ -1417,10 +1441,10 @@ export class MiawClient extends EventEmitter {
                 this.chatsStore.set(originalId, chatInfo);
             }
         }
-        // Persist chats to disk after every update
+        // Persist chats to disk
         // This ensures chats survive reconnections where history sync may not fire
         if (chats.length > 0) {
-            this.saveChatsToFile();
+            this.schedulePersist("chats");
         }
     }
     /**
@@ -1455,6 +1479,26 @@ export class MiawClient extends EventEmitter {
      * @returns true if session was cleared, false if no session existed
      */
     clearSession() {
+        return this.wipeSessionFiles();
+    }
+    /**
+     * Delete the session files and everything cached for the account.
+     *
+     * Pending store writes are dropped and further ones refused until the next
+     * connect(), or a late timer would recreate the deleted dir. The in-memory
+     * stores are emptied too, so the old account's chats and messages are not
+     * written into the next pairing's session.
+     */
+    wipeSessionFiles() {
+        this.cancelPersist();
+        this.persistSuspended = true;
+        this.contactsStore.clear();
+        this.chatsStore.clear();
+        this.messagesStore.clear();
+        this.messageIdIndex.clear();
+        this.labelsStore.clear();
+        this.labelChatsStore.clear();
+        this.lidToJidMap.clear();
         return this.authHandler.clearSession();
     }
     /**
@@ -1471,6 +1515,8 @@ export class MiawClient extends EventEmitter {
         }
         // Reset logout flag
         this.loggingOut = false;
+        // Write anything still pending before the stores are dropped
+        this.flushPersist();
         // Clear LID cache
         this.lidToJidMap.clear();
         // Remove all event listeners
@@ -1519,7 +1565,7 @@ export class MiawClient extends EventEmitter {
         // Don't reconnect if logged out - clear session for fresh QR code on next connect
         if (statusCode === DisconnectReason.loggedOut) {
             this.logger.info("Logged out, clearing session for fresh authentication");
-            this.authHandler.clearSession();
+            this.wipeSessionFiles();
             return false;
         }
         // Don't auto-reconnect when replaced by another connection: reconnecting
@@ -2932,6 +2978,90 @@ export class MiawClient extends EventEmitter {
         };
     }
     // =============================================================================
+    // History Sync Policy & Coalesced Persistence
+    // =============================================================================
+    /**
+     * Whether a history-sync notification of this type should be processed.
+     *
+     * Full mode accepts everything. Lazy mode (the default) accepts only the
+     * bootstrap, small metadata payloads and ON_DEMAND replies, and skips the
+     * bulk RECENT / FULL / status payloads. Never reject every type: ON_DEMAND
+     * is what loadMoreMessages() waits for, and Baileys gets LID mappings only
+     * through history sync.
+     */
+    shouldProcessHistorySync(syncType) {
+        if (this.activeSyncFullHistory)
+            return true;
+        return syncType != null && LAZY_HISTORY_SYNC_TYPES.has(syncType);
+    }
+    /**
+     * Mark a store dirty and (re)arm the write timer.
+     *
+     * Writes are trailing-debounced so a burst - e.g. a history batch of
+     * thousands of messages - costs one write per store instead of one full-file
+     * rewrite per item. PERSIST_MAX_WAIT bounds the delay under sustained
+     * activity so a chatty session still persists.
+     */
+    schedulePersist(store) {
+        if (this.persistSuspended)
+            return;
+        this.dirtyStores.add(store);
+        const now = Date.now();
+        if (this.persistFirstDirtyAt === 0) {
+            this.persistFirstDirtyAt = now;
+        }
+        const remaining = TIMEOUTS.PERSIST_MAX_WAIT - (now - this.persistFirstDirtyAt);
+        const delay = Math.max(0, Math.min(TIMEOUTS.PERSIST_DEBOUNCE, remaining));
+        if (this.persistTimer) {
+            clearTimeout(this.persistTimer);
+        }
+        this.persistTimer = setTimeout(() => this.flushPersist(), delay);
+        // Never hold the process open just to write a cache.
+        this.persistTimer.unref?.();
+    }
+    /** Write every dirty store now. */
+    flushPersist() {
+        const dirty = [...this.dirtyStores];
+        this.cancelPersist();
+        for (const store of dirty) {
+            switch (store) {
+                case "messages":
+                    this.saveMessagesToFile();
+                    break;
+                case "chats":
+                    this.saveChatsToFile();
+                    break;
+                case "contacts":
+                    this.saveContactsToFile();
+                    break;
+                case "lid":
+                    this.saveLidMappingsToFile();
+                    break;
+                case "labels":
+                    this.saveLabelsToFile();
+                    break;
+            }
+        }
+    }
+    /** Drop pending writes without writing them. */
+    cancelPersist() {
+        if (this.persistTimer) {
+            clearTimeout(this.persistTimer);
+            this.persistTimer = null;
+        }
+        this.dirtyStores.clear();
+        this.persistFirstDirtyAt = 0;
+    }
+    /**
+     * Write JSON via a temp file + rename, so a crash mid-write never leaves a
+     * truncated store behind. Compact output: these are caches, not configs.
+     */
+    writeJsonFileAtomic(filePath, data) {
+        const tmpPath = `${filePath}.tmp`;
+        fs.writeFileSync(tmpPath, JSON.stringify(data), "utf8");
+        fs.renameSync(tmpPath, filePath);
+    }
+    // =============================================================================
     // Persistent Label Storage
     // =============================================================================
     /**
@@ -2955,7 +3085,7 @@ export class MiawClient extends EventEmitter {
             }
             // Convert Map to array for JSON serialization
             const labelsData = Array.from(this.labelsStore.values());
-            fs.writeFileSync(labelsPath, JSON.stringify(labelsData, null, 2), "utf8");
+            this.writeJsonFileAtomic(labelsPath, labelsData);
             this.logger.debug(`Saved ${labelsData.length} labels to ${labelsPath}`);
         }
         catch (error) {
@@ -3023,7 +3153,7 @@ export class MiawClient extends EventEmitter {
                 }
             }
             const contactsData = Array.from(uniqueContacts.values());
-            fs.writeFileSync(contactsPath, JSON.stringify(contactsData, null, 2), "utf8");
+            this.writeJsonFileAtomic(contactsPath, contactsData);
             this.logger.debug(`Saved ${contactsData.length} contacts to ${contactsPath}`);
         }
         catch (error) {
@@ -3079,7 +3209,7 @@ export class MiawClient extends EventEmitter {
             const mappings = this.getLidMappings();
             const count = Object.keys(mappings).length;
             if (count > 0) {
-                fs.writeFileSync(mappingsPath, JSON.stringify(mappings, null, 2), "utf8");
+                this.writeJsonFileAtomic(mappingsPath, mappings);
                 this.logger.debug(`Saved ${count} LID mappings to ${mappingsPath}`);
             }
         }
@@ -3141,7 +3271,7 @@ export class MiawClient extends EventEmitter {
                 }
             }
             const chatsData = Array.from(uniqueChats.values());
-            fs.writeFileSync(chatsPath, JSON.stringify(chatsData, null, 2), "utf8");
+            this.writeJsonFileAtomic(chatsPath, chatsData);
             this.logger.debug(`Saved ${chatsData.length} chats to ${chatsPath}`);
         }
         catch (error) {
@@ -3194,18 +3324,26 @@ export class MiawClient extends EventEmitter {
      */
     storeMessage(normalized) {
         const chatJid = normalized.from;
-        const bucket = this.messagesStore.get(chatJid);
-        if (bucket) {
-            // Dedup by id. An empty id (missing key.id) can't be deduped -> append.
-            if (normalized.id && bucket.some((m) => m.id === normalized.id)) {
+        let ids = this.messageIdIndex.get(chatJid);
+        if (!ids) {
+            ids = new Set();
+            this.messageIdIndex.set(chatJid, ids);
+        }
+        // Dedup by id. An empty id (missing key.id) can't be deduped -> append.
+        if (normalized.id) {
+            if (ids.has(normalized.id)) {
                 return false;
             }
+            ids.add(normalized.id);
+        }
+        const bucket = this.messagesStore.get(chatJid);
+        if (bucket) {
             bucket.push(normalized);
         }
         else {
             this.messagesStore.set(chatJid, [normalized]);
         }
-        this.saveMessagesToFile();
+        this.schedulePersist("messages");
         return true;
     }
     /**
@@ -3228,7 +3366,7 @@ export class MiawClient extends EventEmitter {
             }
             // Count total messages
             const totalMessages = Array.from(this.messagesStore.values()).reduce((sum, msgs) => sum + msgs.length, 0);
-            fs.writeFileSync(messagesPath, JSON.stringify(messagesData, null, 2), "utf8");
+            this.writeJsonFileAtomic(messagesPath, messagesData);
             this.logger.debug(`Saved ${totalMessages} messages across ${this.messagesStore.size} chats to ${messagesPath}`);
         }
         catch (error) {
@@ -3250,10 +3388,12 @@ export class MiawClient extends EventEmitter {
             if (messagesData && typeof messagesData === "object") {
                 // Clear existing store and populate from file
                 this.messagesStore.clear();
+                this.messageIdIndex.clear();
                 let totalMessages = 0;
                 for (const [jid, messages] of Object.entries(messagesData)) {
                     if (Array.isArray(messages)) {
                         this.messagesStore.set(jid, messages);
+                        this.messageIdIndex.set(jid, new Set(messages.map((m) => m.id).filter(Boolean)));
                         totalMessages += messages.length;
                     }
                 }
@@ -6548,6 +6688,8 @@ export class MiawClient extends EventEmitter {
         this.activeProxyKey = undefined;
         // Cleanup console filter if it was enabled (reference counted)
         this.releaseConsoleFilter();
+        // Session is preserved, so pending store writes must land
+        this.flushPersist();
         this.updateConnectionState("disconnected");
         this.logger.info("Disconnected (session preserved)");
         // The `disconnected` event previously fired only from handleDisconnect(),
@@ -6656,8 +6798,8 @@ export class MiawClient extends EventEmitter {
             this.socket.end(undefined);
             this.socket = null;
         }
-        // Clear session files
-        this.authHandler.clearSession();
+        // Clear session files (and drop pending store writes with them)
+        this.wipeSessionFiles();
         // Reset logout flag
         this.loggingOut = false;
         // Cleanup console filter if it was enabled (reference counted)
@@ -6762,21 +6904,24 @@ export class MiawClient extends EventEmitter {
         }
     }
     /**
-     * Enable history sync for next connection
+     * Request the phone's full message history on the next connection.
+     * Only a fresh pairing receives it; an existing session is not re-synced.
      */
     enableSync() {
         this.options.syncFullHistory = true;
-        this.logger.info("History sync enabled (will take effect on next connect)");
+        this.logger.info("Full history sync enabled (will take effect on next connect)");
     }
     /**
-     * Disable history sync for next connection
+     * Ingest only the bootstrap on the next connection (the default). The
+     * bootstrap and on-demand replies are still processed, so loadMoreMessages()
+     * keeps working.
      */
     disableSync() {
         this.options.syncFullHistory = false;
-        this.logger.info("History sync disabled (will take effect on next connect)");
+        this.logger.info("Full history sync disabled (bootstrap + on-demand still active; takes effect on next connect)");
     }
     /**
-     * Check if history sync is enabled
+     * Check if full history sync is enabled
      */
     isSyncEnabled() {
         return this.options.syncFullHistory;