app-manager-edge-worker 1.1.2 → 1.1.4

package/src/handlers/whatsappHandler.js

@@ -36,18 +36,116 @@ export class WhatsAppWorkerHandler {
         this.IDLE_COOLDOWN_MS = options.idleCooldownMs || 10 * 60 * 1000; // 10 minutes
         this.onStatusChange = options.onStatusChange || (() => {});
         this.onQrGenerated = options.onQrGenerated || (() => {});
+        this.onSessionBatchUpdate = options.onSessionBatchUpdate || (() => {});
+        this.onClearSession = options.onClearSession || (() => {});
         this.chatStore = new Map(); // JID -> Array of recent messages for reconciliation
         this.isInitializing = false;
+        this.pendingWrites = new Map(); // keyId -> string data
+        this.pendingDeletes = new Set(); // keyId
+        this.syncDebounceTimer = null;
 
         if (!fs.existsSync(this.authDir)) {
             fs.mkdirSync(this.authDir, { recursive: true });
         }
     }
 
+    /**
+     * Queues a key write to be batched and synced to the central MongoDB server.
+     */
+    queueSyncWrite(keyId, data) {
+        if (!keyId || typeof data !== "string") return;
+        this.pendingDeletes.delete(keyId);
+        this.pendingWrites.set(keyId, data);
+        this._scheduleBatchSync();
+    }
+
+    /**
+     * Queues a key removal to be batched and deleted from central MongoDB server.
+     */
+    queueSyncDelete(keyId) {
+        if (!keyId) return;
+        this.pendingWrites.delete(keyId);
+        this.pendingDeletes.add(keyId);
+        this._scheduleBatchSync();
+    }
+
+    /**
+     * Debounces and dispatches batched key updates to the cluster WebSocket.
+     */
+    _scheduleBatchSync() {
+        if (this.syncDebounceTimer) return;
+        this.syncDebounceTimer = setTimeout(() => {
+            this.syncDebounceTimer = null;
+            if (this.pendingWrites.size === 0 && this.pendingDeletes.size === 0) return;
+
+            const writes = [];
+            for (const [keyId, data] of this.pendingWrites.entries()) {
+                writes.push({ keyId, data });
+            }
+            const deletes = Array.from(this.pendingDeletes);
+
+            this.pendingWrites.clear();
+            this.pendingDeletes.clear();
+
+            this.onSessionBatchUpdate({ writes, deletes });
+        }, 150);
+    }
+
+    /**
+     * Hydrates local session disk cache with stored credentials from MongoDB.
+     */
+    hydrateFromSessionFiles(files) {
+        if (!files || typeof files !== "object") return;
+        if (!fs.existsSync(this.authDir)) {
+            fs.mkdirSync(this.authDir, { recursive: true });
+        }
+
+        let hydratedCount = 0;
+        for (const [filename, content] of Object.entries(files)) {
+            if (!filename || typeof content !== "string") continue;
+            const safeName = filename.replace(/\//g, "__").replace(/:/g, "-");
+            const targetPath = path.join(this.authDir, safeName);
+            try {
+                fs.writeFileSync(targetPath, content, "utf-8");
+                hydratedCount++;
+            } catch (err) {
+                console.error(`[WhatsApp Worker] Failed to hydrate ${filename}:`, err.message);
+            }
+        }
+        console.log(`[WhatsApp Worker] Successfully hydrated ${hydratedCount} session files from MongoDB.`);
+    }
+
+    /**
+     * Reads all local JSON credential files from disk for initial backup to MongoDB.
+     */
+    exportAllSessionFiles() {
+        if (!fs.existsSync(this.authDir)) return {};
+        const result = {};
+        try {
+            const files = fs.readdirSync(this.authDir);
+            for (const file of files) {
+                if (file.endsWith(".json")) {
+                    try {
+                        const content = fs.readFileSync(path.join(this.authDir, file), "utf-8");
+                        result[file] = content;
+                    } catch (_) {}
+                }
+            }
+        } catch (_) {}
+        return result;
+    }
+
     /**
      * Wipes local stored credentials.
      */
     clearAuth() {
+        this.pendingWrites.clear();
+        this.pendingDeletes.clear();
+        if (this.syncDebounceTimer) {
+            clearTimeout(this.syncDebounceTimer);
+            this.syncDebounceTimer = null;
+        }
+
         if (fs.existsSync(this.authDir)) {
             try {
                 fs.rmSync(this.authDir, { recursive: true, force: true });
@@ -142,6 +240,44 @@ export class WhatsAppWorkerHandler {
 
         try {
             const { state, saveCreds } = await useMultiFileAuthState(this.authDir);
+
+            // Wrap saveCreds to mirror credentials to central MongoDB
+            const originalSaveCreds = saveCreds;
+            const wrappedSaveCreds = async () => {
+                await originalSaveCreds();
+                try {
+                    const credsPath = path.join(this.authDir, "creds.json");
+                    if (fs.existsSync(credsPath)) {
+                        const credsStr = fs.readFileSync(credsPath, "utf-8");
+                        this.queueSyncWrite("creds.json", credsStr);
+                    }
+                } catch (_) {}
+            };
+
+            // Wrap state.keys.set to mirror key additions, updates and removals to central MongoDB
+            const originalKeysSet = state.keys.set;
+            state.keys.set = async (data) => {
+                await originalKeysSet(data);
+                for (const category in data) {
+                    for (const id in data[category]) {
+                        const value = data[category][id];
+                        const file = `${category}-${id}.json`;
+                        const safeName = file.replace(/\//g, "__").replace(/:/g, "-");
+                        if (value) {
+                            try {
+                                const filePath = path.join(this.authDir, safeName);
+                                if (fs.existsSync(filePath)) {
+                                    const content = fs.readFileSync(filePath, "utf-8");
+                                    this.queueSyncWrite(safeName, content);
+                                }
+                            } catch (_) {}
+                        } else {
+                            this.queueSyncDelete(safeName);
+                        }
+                    }
+                }
+            };
+
             let version = undefined;
             try {
                 const fetched = await fetchLatestBaileysVersion();
@@ -167,7 +303,7 @@ export class WhatsAppWorkerHandler {
 
             this.sock = makeWASocket(socketConfig);
 
-            this.sock.ev.on("creds.update", saveCreds);
+            this.sock.ev.on("creds.update", wrappedSaveCreds);
 
             // Message Upsert listener for companion store sync & pre-send delivery reconciliation
             this.sock.ev.on("messages.upsert", ({ messages }) => {
@@ -243,6 +379,7 @@ export class WhatsAppWorkerHandler {
                         this.user = null;
                         this.currentQrDataUrl = null;
                         this.clearAuth();
+                        this.onClearSession();
 
                         if (this.sock) {
                             try {
@@ -422,15 +559,23 @@ export class WhatsAppWorkerHandler {
         // 3. Stream PDF from authenticated URL (Zero buffer in central WebSocket)
         const response = await axios.get(downloadUrl, {
             responseType: "arraybuffer",
-            timeout: 20000,
+            timeout: 25000,
         });
 
         const buffer = Buffer.from(response.data);
+        if (!buffer || buffer.length === 0) {
+            throw new Error(`Failed to download document: received 0 bytes from ${downloadUrl}`);
+        }
 
         // 4. SHA-256 Integrity Verification
+        const actualSha256 = crypto.createHash("sha256").update(buffer).digest("hex");
+        const serverSha256 = response.headers?.["x-sha256"] || response.headers?.["x-checksum-sha256"];
+
         if (expectedSha256) {
-            const actualSha256 = crypto.createHash("sha256").update(buffer).digest("hex");
-            if (actualSha256.toLowerCase() !== expectedSha256.toLowerCase()) {
+            const matchesExpected = actualSha256.toLowerCase() === expectedSha256.toLowerCase();
+            const matchesServerHeader = serverSha256 && actualSha256.toLowerCase() === String(serverSha256).toLowerCase();
+
+            if (!matchesExpected && !matchesServerHeader) {
                 throw new Error(
                     `Document integrity check failed. Expected SHA-256 ${expectedSha256}, got ${actualSha256}`
                 );
@@ -481,6 +626,7 @@ export class WhatsAppWorkerHandler {
         }
 
         this.clearAuth();
+        this.onClearSession();
         this.status = "DISCONNECTED";
         this.user = null;
         this.currentQrDataUrl = null;

package/LICENSE.txt

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Chetan Mohite
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.