app-manager-edge-worker 1.0.8 → 1.1.0

package/src/handlers/whatsappHandler.js

@@ -0,0 +1,492 @@
+import makeWASocket, {
+    DisconnectReason,
+    useMultiFileAuthState,
+    fetchLatestBaileysVersion,
+    Browsers,
+} from "@whiskeysockets/baileys";
+import pino from "pino";
+import qrcode from "qrcode";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import crypto from "crypto";
+import axios from "axios";
+
+/**
+ * WhatsApp Companion Device Engine for App Manager Edge Worker.
+ *
+ * Implements:
+ * 1. Independent Companion Device Pairing (Multi-Device Protocol).
+ * 2. Stealth Presence (markOnlineOnConnect: false).
+ * 3. Smart On-Demand Wakeup with 10-minute Idle Cooldown.
+ * 4. Signed Ephemeral Document Streaming & SHA-256 Integrity Verification.
+ * 5. Pre-Send Delivery Reconciliation via Synced Chat Store.
+ * 6. Mobile App Unlink Detection & Bidirectional Remote Logout.
+ */
+export class WhatsAppWorkerHandler {
+    constructor(options = {}) {
+        const homeDir = os.homedir();
+        const baseDir = options.authDir || path.join(homeDir, ".app-manager-edge-worker", "wa-session");
+        this.authDir = baseDir;
+        this.sock = null;
+        this.status = "DISCONNECTED"; // DISCONNECTED | PAIRING | CONNECTED | STANDBY
+        this.user = null; // { id, name, phone }
+        this.currentQrDataUrl = null;
+        this.idleTimer = null;
+        this.IDLE_COOLDOWN_MS = options.idleCooldownMs || 10 * 60 * 1000; // 10 minutes
+        this.onStatusChange = options.onStatusChange || (() => {});
+        this.onQrGenerated = options.onQrGenerated || (() => {});
+        this.chatStore = new Map(); // JID -> Array of recent messages for reconciliation
+        this.isInitializing = false;
+
+        if (!fs.existsSync(this.authDir)) {
+            fs.mkdirSync(this.authDir, { recursive: true });
+        }
+    }
+
+    /**
+     * Wipes local stored credentials.
+     */
+    clearAuth() {
+        if (fs.existsSync(this.authDir)) {
+            try {
+                fs.rmSync(this.authDir, { recursive: true, force: true });
+            } catch (_) {
+                try {
+                    const files = fs.readdirSync(this.authDir);
+                    for (const file of files) {
+                        fs.rmSync(path.join(this.authDir, file), { recursive: true, force: true });
+                    }
+                } catch (__) {}
+            }
+        }
+        if (!fs.existsSync(this.authDir)) {
+            fs.mkdirSync(this.authDir, { recursive: true });
+        }
+    }
+
+    /**
+     * Checks if local credentials exist on disk.
+     */
+    hasCredentials() {
+        const credsPath = path.join(this.authDir, "creds.json");
+        return fs.existsSync(credsPath);
+    }
+
+    /**
+     * Resets the 10-minute idle timer. Puts the socket into graceful standby when inactive.
+     */
+    _resetIdleTimer() {
+        if (this.idleTimer) {
+            clearTimeout(this.idleTimer);
+            this.idleTimer = null;
+        }
+
+        this.idleTimer = setTimeout(() => {
+            if (this.sock && this.status === "CONNECTED") {
+                this._sleepSocket();
+            }
+        }, this.IDLE_COOLDOWN_MS);
+    }
+
+    /**
+     * Gracefully puts the socket to sleep after the idle cooldown expires.
+     */
+    _sleepSocket() {
+        if (this.sock) {
+            try {
+                this.sock.end(undefined);
+            } catch (_) {}
+            this.sock = null;
+        }
+        this.status = "STANDBY";
+        this.onStatusChange({
+            status: "STANDBY",
+            phone: this.user?.phone || null,
+            name: this.user?.name || null,
+        });
+    }
+
+    /**
+     * Initializes the Baileys socket.
+     * Can be invoked for pairing (requestQr=true) or on-demand send.
+     */
+    async initialize(requestQr = false) {
+        if (this.sock && this.status === "CONNECTED") {
+            this._resetIdleTimer();
+            return this.sock;
+        }
+
+        if (this.isInitializing) {
+            // Wait for existing initialization to finish
+            for (let i = 0; i < 30; i++) {
+                await new Promise((r) => setTimeout(r, 200));
+                if (this.sock && this.status === "CONNECTED") return this.sock;
+                if (!this.isInitializing) break;
+            }
+        }
+
+        this.isInitializing = true;
+        this.status = requestQr ? "PAIRING" : "STANDBY";
+
+        try {
+            const { state, saveCreds } = await useMultiFileAuthState(this.authDir);
+            const { version } = await fetchLatestBaileysVersion().catch(() => ({
+                version: [2, 3000, 1015901307],
+            }));
+
+            const logger = pino({ level: "silent" });
+
+            this.sock = makeWASocket({
+                version,
+                auth: state,
+                logger,
+                printQRInTerminal: false,
+                browser: Browsers.ubuntu("Desktop"),
+                syncFullHistory: false,
+                markOnlineOnConnect: false, // Stealth Presence: Does NOT broadcast green online dot
+                generateHighQualityLinkPreview: true,
+            });
+
+            this.sock.ev.on("creds.update", saveCreds);
+
+            // Message Upsert listener for companion store sync & pre-send delivery reconciliation
+            this.sock.ev.on("messages.upsert", ({ messages }) => {
+                if (!messages || !Array.isArray(messages)) return;
+                for (const msg of messages) {
+                    const jid = msg.key?.remoteJid;
+                    if (!jid) continue;
+                    if (!this.chatStore.has(jid)) {
+                        this.chatStore.set(jid, []);
+                    }
+                    const list = this.chatStore.get(jid);
+                    list.unshift(msg);
+                    if (list.length > 50) list.pop(); // Keep last 50 messages per JID
+                }
+            });
+
+            this.sock.ev.on("connection.update", async (update) => {
+                const { connection, lastDisconnect, qr } = update;
+
+                if (qr) {
+                    this.status = "PAIRING";
+                    try {
+                        this.currentQrDataUrl = await qrcode.toDataURL(qr);
+                        this.onQrGenerated({ qrDataUrl: this.currentQrDataUrl });
+                    } catch (err) {
+                        console.error("[WhatsApp Worker] Failed to render QR Data URL:", err);
+                    }
+                }
+
+                if (connection === "open") {
+                    this.status = "CONNECTED";
+                    this.currentQrDataUrl = null;
+                    this.isInitializing = false;
+
+                    const rawId = this.sock?.user?.id || "";
+                    const phone = rawId.split(":")[0] || rawId.split("@")[0];
+                    this.user = {
+                        id: rawId,
+                        name: this.sock?.user?.name || undefined,
+                        phone,
+                    };
+
+                    this._resetIdleTimer();
+
+                    this.onStatusChange({
+                        status: "CONNECTED",
+                        phone: this.user.phone,
+                        name: this.user.name,
+                        deviceJid: rawId,
+                    });
+                }
+
+                if (connection === "close") {
+                    this.isInitializing = false;
+                    const statusCode = (lastDisconnect?.error)?.output?.statusCode;
+                    const isLoggedOut =
+                        statusCode === DisconnectReason.loggedOut ||
+                        statusCode === 401 ||
+                        statusCode === DisconnectReason.badSession;
+
+                    if (isLoggedOut) {
+                        // Mobile App or Meta unlinked this companion device
+                        this.status = "DISCONNECTED";
+                        this.user = null;
+                        this.currentQrDataUrl = null;
+                        this.clearAuth();
+
+                        if (this.sock) {
+                            try {
+                                this.sock.end(undefined);
+                            } catch (_) {}
+                            this.sock = null;
+                        }
+
+                        this.onStatusChange({
+                            status: "DISCONNECTED",
+                            reason: "LOGGED_OUT_BY_PHONE",
+                        });
+                    } else {
+                        // Temporary disconnect / network blip
+                        this.status = "STANDBY";
+                    }
+                }
+            });
+
+            // Wait up to 6 seconds for connection if credentials exist
+            if (this.hasCredentials()) {
+                for (let i = 0; i < 30; i++) {
+                    await new Promise((r) => setTimeout(r, 200));
+                    if (this.status === "CONNECTED") break;
+                }
+            }
+
+            return this.sock;
+        } catch (err) {
+            this.status = "DISCONNECTED";
+            this.isInitializing = false;
+            throw err;
+        } finally {
+            this.isInitializing = false;
+        }
+    }
+
+    /**
+     * Pre-Send Delivery Reconciliation:
+     * Checks local companion chat store to verify if an invoice or message with the given
+     * idempotencyKey was already emitted (e.g. prior to a worker crash or synced from phone).
+     */
+    async reconcileDelivery(recipientPhone, idempotencyKey) {
+        if (!idempotencyKey) return null;
+        const jid = this._formatJid(recipientPhone);
+        const list = this.chatStore.get(jid) || [];
+
+        for (const msg of list) {
+            if (!msg.key?.fromMe) continue;
+            const textContent =
+                msg.message?.conversation ||
+                msg.message?.extendedTextMessage?.text ||
+                msg.message?.documentMessage?.caption ||
+                "";
+
+            if (textContent.includes(idempotencyKey)) {
+                return {
+                    reconciled: true,
+                    messageId: msg.key.id,
+                    timestamp: msg.messageTimestamp,
+                };
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Sends a plain text WhatsApp message with typing simulation and jitter.
+     */
+    async sendMessage({ recipientPhone, message, idempotencyKey = null }) {
+        await this.initialize(false);
+        if (!this.sock || this.status !== "CONNECTED") {
+            throw new Error("WhatsApp companion device is not connected. Please pair via Admin Panel.");
+        }
+
+        const jid = this._formatJid(recipientPhone);
+
+        // 1. Reconciliation check
+        if (idempotencyKey) {
+            const alreadyDelivered = await this.reconcileDelivery(recipientPhone, idempotencyKey);
+            if (alreadyDelivered) {
+                return {
+                    success: true,
+                    reconciled: true,
+                    messageId: alreadyDelivered.messageId,
+                    note: "Delivery reconciled via companion message sync; duplicate dispatch aborted.",
+                };
+            }
+        }
+
+        // 2. Account verification on WhatsApp
+        const digits = recipientPhone.replace(/\D/g, "");
+        const [verified] = await this.sock.onWhatsApp(digits).catch(() => [null]);
+        if (!verified || !verified.exists) {
+            throw new Error(`Recipient ${recipientPhone} is not registered on WhatsApp.`);
+        }
+        const targetJid = verified.jid || jid;
+
+        // 3. Human Typing Simulation
+        await this.sock.sendPresenceUpdate("composing", targetJid).catch(() => {});
+        const typingDurationMs = Math.min(Math.max((message.length || 20) * 35, 2000), 4500);
+        await new Promise((r) => setTimeout(r, typingDurationMs));
+        await this.sock.sendPresenceUpdate("paused", targetJid).catch(() => {});
+        await new Promise((r) => setTimeout(r, 300));
+
+        // 4. Append idempotency reference if provided
+        let finalMessage = message;
+        if (idempotencyKey && !finalMessage.includes(idempotencyKey)) {
+            finalMessage += `\n\n[Ref: ${idempotencyKey}]`;
+        }
+
+        // 5. Dispatch
+        const result = await this.sock.sendMessage(targetJid, { text: finalMessage });
+        this._resetIdleTimer();
+
+        return {
+            success: true,
+            messageId: result?.key?.id || `wamid-${Date.now()}`,
+            timestamp: Date.now(),
+        };
+    }
+
+    /**
+     * Streams a canonical PDF invoice from a signed download URL, verifies SHA-256 hash,
+     * and sends it as an attachment over WhatsApp with typing presence.
+     */
+    async sendDocument({
+        recipientPhone,
+        downloadUrl,
+        expectedSha256,
+        fileName = "Invoice.pdf",
+        mimetype = "application/pdf",
+        caption = "",
+        idempotencyKey = null,
+    }) {
+        await this.initialize(false);
+        if (!this.sock || this.status !== "CONNECTED") {
+            throw new Error("WhatsApp companion device is not connected. Please pair via Admin Panel.");
+        }
+
+        const jid = this._formatJid(recipientPhone);
+
+        // 1. Reconciliation check
+        if (idempotencyKey) {
+            const alreadyDelivered = await this.reconcileDelivery(recipientPhone, idempotencyKey);
+            if (alreadyDelivered) {
+                return {
+                    success: true,
+                    reconciled: true,
+                    messageId: alreadyDelivered.messageId,
+                    note: "Invoice delivery reconciled via companion sync; duplicate dispatch aborted.",
+                };
+            }
+        }
+
+        // 2. Verify recipient on WhatsApp
+        const digits = recipientPhone.replace(/\D/g, "");
+        const [verified] = await this.sock.onWhatsApp(digits).catch(() => [null]);
+        if (!verified || !verified.exists) {
+            throw new Error(`Recipient ${recipientPhone} is not registered on WhatsApp.`);
+        }
+        const targetJid = verified.jid || jid;
+
+        // 3. Stream PDF from authenticated URL (Zero buffer in central WebSocket)
+        const response = await axios.get(downloadUrl, {
+            responseType: "arraybuffer",
+            timeout: 20000,
+        });
+
+        const buffer = Buffer.from(response.data);
+
+        // 4. SHA-256 Integrity Verification
+        if (expectedSha256) {
+            const actualSha256 = crypto.createHash("sha256").update(buffer).digest("hex");
+            if (actualSha256.toLowerCase() !== expectedSha256.toLowerCase()) {
+                throw new Error(
+                    `Document integrity check failed. Expected SHA-256 ${expectedSha256}, got ${actualSha256}`
+                );
+            }
+        }
+
+        // 5. Human Typing Simulation
+        await this.sock.sendPresenceUpdate("composing", targetJid).catch(() => {});
+        await new Promise((r) => setTimeout(r, 2500));
+        await this.sock.sendPresenceUpdate("paused", targetJid).catch(() => {});
+        await new Promise((r) => setTimeout(r, 300));
+
+        // 6. Append idempotency reference to caption
+        let finalCaption = caption;
+        if (idempotencyKey && !finalCaption.includes(idempotencyKey)) {
+            finalCaption += `\n\n[Ref: ${idempotencyKey}]`;
+        }
+
+        // 7. Dispatch document attachment
+        const result = await this.sock.sendMessage(targetJid, {
+            document: buffer,
+            mimetype,
+            fileName,
+            caption: finalCaption,
+        });
+
+        this._resetIdleTimer();
+
+        return {
+            success: true,
+            messageId: result?.key?.id || `wamid-${Date.now()}`,
+            timestamp: Date.now(),
+        };
+    }
+
+    /**
+     * Remote Logout triggered from the Admin Panel.
+     */
+    async logout() {
+        if (this.sock) {
+            try {
+                await this.sock.logout();
+            } catch (_) {}
+            try {
+                this.sock.end(undefined);
+            } catch (_) {}
+            this.sock = null;
+        }
+
+        this.clearAuth();
+        this.status = "DISCONNECTED";
+        this.user = null;
+        this.currentQrDataUrl = null;
+
+        this.onStatusChange({
+            status: "DISCONNECTED",
+            reason: "ADMIN_REMOTE_LOGOUT",
+        });
+
+        return { success: true };
+    }
+
+    /**
+     * Returns real-time worker telemetry & capacity metrics.
+     */
+    getTelemetry() {
+        const totalMem = Math.round(os.totalmem() / (1024 * 1024));
+        const freeMem = Math.round(os.freemem() / (1024 * 1024));
+        const processMem = Math.round(process.memoryUsage().rss / (1024 * 1024));
+
+        return {
+            status: this.status,
+            user: this.user,
+            hasStoredCredentials: this.hasCredentials(),
+            freeSystemMemoryMb: freeMem,
+            totalSystemMemoryMb: totalMem,
+            processMemoryMb: processMem,
+            memoryPressure: Number(((totalMem - freeMem) / totalMem).toFixed(2)),
+            qrCodeDataUrl: this.currentQrDataUrl,
+        };
+    }
+
+    _formatJid(phone) {
+        let clean = String(phone).trim();
+        if (clean.endsWith("@s.whatsapp.net")) return clean;
+        const digits = clean.replace(/\D/g, "");
+        return `${digits}@s.whatsapp.net`;
+    }
+}
+
+let instance = null;
+
+export function getWhatsAppHandler(options = {}) {
+    if (!instance) {
+        instance = new WhatsAppWorkerHandler(options);
+    }
+    return instance;
+}
+
+export default getWhatsAppHandler;