@sjawhar/whatsapp-mcp 1.0.0

package/dist/whatsapp.js

@@ -0,0 +1,896 @@
+import makeWASocket, { DisconnectReason, fetchLatestBaileysVersion, downloadMediaMessage, getContentType, initAuthCreds, BufferJSON, proto, } from "@whiskeysockets/baileys";
+import pino from "pino";
+import NodeCache from "node-cache";
+import fs from "fs";
+import path from "path";
+import { toJid, fromJid, mimeFromExtension, mediaCategoryFromMime, validateFilePath, sanitizeFilename, } from "./utils.js";
+import * as db from "./db.js";
+import { transcribeAudio } from "./transcribe.js";
+const __project_root = path.resolve(path.dirname(new URL(import.meta.url).pathname), "..");
+const AUTH_DIR = path.join(__project_root, "auth_info");
+const DOWNLOADS_DIR = process.env.DOWNLOADS_DIR || "./downloads/";
+const parsedMaxReconnectAttempts = Number(process.env.MAX_RECONNECT_ATTEMPTS || "10");
+const MAX_RECONNECT_ATTEMPTS = Number.isFinite(parsedMaxReconnectAttempts) && parsedMaxReconnectAttempts > 0
+    ? Math.floor(parsedMaxReconnectAttempts)
+    : 10;
+const parsedZombieTimeoutMs = Number(process.env.ZOMBIE_TIMEOUT_MS || "120000");
+const ZOMBIE_TIMEOUT_MS = Number.isFinite(parsedZombieTimeoutMs) && parsedZombieTimeoutMs > 0
+    ? Math.floor(parsedZombieTimeoutMs)
+    : 120000;
+const parsedMaxSendFailures = Number(process.env.MAX_SEND_FAILURES || "3");
+const MAX_SEND_FAILURES = Number.isFinite(parsedMaxSendFailures) && parsedMaxSendFailures > 0
+    ? Math.floor(parsedMaxSendFailures)
+    : 3;
+const parsedMinSendInterval = Number(process.env.MIN_SEND_INTERVAL_MS || "3000");
+const MIN_SEND_INTERVAL_MS = Number.isFinite(parsedMinSendInterval) && parsedMinSendInterval >= 0
+    ? Math.floor(parsedMinSendInterval)
+    : 3000;
+const parsedSendJitter = Number(process.env.SEND_JITTER_MS || "2000");
+const SEND_JITTER_MS = Number.isFinite(parsedSendJitter) && parsedSendJitter >= 0
+    ? Math.floor(parsedSendJitter)
+    : 2000;
+export class SendRateLimiter {
+    lastSendTimestamp = 0;
+    minInterval;
+    jitterMs;
+    constructor(minInterval, jitterMs) {
+        this.minInterval = minInterval;
+        this.jitterMs = jitterMs;
+    }
+    async throttle() {
+        const now = Date.now();
+        const elapsed = now - this.lastSendTimestamp;
+        const jitter = Math.random() * this.jitterMs;
+        const delay = Math.max(0, this.minInterval - elapsed) + jitter;
+        if (delay > 0) {
+            await new Promise(resolve => setTimeout(resolve, delay));
+        }
+        this.lastSendTimestamp = Date.now();
+    }
+}
+const sendRateLimiter = new SendRateLimiter(MIN_SEND_INTERVAL_MS, SEND_JITTER_MS);
+const PRE_KEY_PRUNE_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
+const PRE_KEY_MAX_FILES = 500;
+const PRE_KEY_KEEP_FILES = 100;
+const logger = pino({ level: "warn" }, pino.destination({ dest: 2, sync: false }));
+// ─── Atomic Multi-File Auth State ───────────────────────────────────
+// Custom replacement for Baileys' useMultiFileAuthState that uses atomic
+// writes (write-to-temp + rename) to prevent JSON corruption from
+// concurrent writes during app state sync. The built-in implementation
+// uses plain writeFile which can produce corrupted files when two events
+// write to the same key file in quick succession.
+let pendingWrites = new Set();
+function trackWrite(p) {
+    pendingWrites.add(p);
+    p.finally(() => pendingWrites.delete(p));
+    return p;
+}
+async function flushPendingWrites() {
+    if (pendingWrites.size > 0) {
+        console.error(`Flushing ${pendingWrites.size} pending auth write(s)...`);
+        await Promise.allSettled([...pendingWrites]);
+    }
+}
+async function atomicWrite(filePath, data) {
+    const tmpPath = filePath + '.tmp.' + process.pid + '.' + Date.now() + '.' + Math.random().toString(36).slice(2);
+    await fs.promises.writeFile(tmpPath, data);
+    await fs.promises.rename(tmpPath, filePath);
+}
+async function useAtomicMultiFileAuthState(folder) {
+    await fs.promises.mkdir(folder, { recursive: true });
+    const writeData = async (data, file) => {
+        const filePath = path.join(folder, sanitizeFilename(file));
+        await atomicWrite(filePath, JSON.stringify(data, BufferJSON.replacer));
+    };
+    const readData = async (file) => {
+        try {
+            const filePath = path.join(folder, sanitizeFilename(file));
+            const raw = await fs.promises.readFile(filePath, { encoding: "utf-8" });
+            return JSON.parse(raw, BufferJSON.reviver);
+        }
+        catch {
+            return null;
+        }
+    };
+    const removeData = async (file) => {
+        try {
+            await fs.promises.unlink(path.join(folder, sanitizeFilename(file)));
+        }
+        catch { }
+    };
+    const creds = (await readData("creds.json")) || initAuthCreds();
+    return {
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids) => {
+                    const data = {};
+                    await Promise.all(ids.map(async (id) => {
+                        let value = await readData(`${type}-${id}.json`);
+                        if (type === "app-state-sync-key" && value) {
+                            value = proto.Message.AppStateSyncKeyData.fromObject(value);
+                        }
+                        if (value) {
+                            data[id] = value;
+                        }
+                    }));
+                    return data;
+                },
+                set: async (data) => {
+                    const tasks = [];
+                    for (const category in data) {
+                        for (const id in data[category]) {
+                            const value = data[category][id];
+                            const file = `${category}-${id}.json`;
+                            tasks.push(value ? writeData(value, file) : removeData(file));
+                        }
+                    }
+                    await Promise.all(tasks);
+                },
+            },
+        },
+        saveCreds: () => writeData(creds, "creds.json"),
+    };
+}
+// ─── Connection State ───────────────────────────────────────────────
+let sock = null;
+let connectionReady;
+let resolveConnection;
+let rejectConnection;
+let reconnectAttempts = 0;
+let reconnectTimer = null;
+let zombieWatchdog = null;
+let lastConnectionActivity = Date.now();
+let consecutiveSendFailures = 0;
+let preKeyPruneInterval = null;
+// ─── User Identity ──────────────────────────────────────────────────
+let myJid = null;
+let myName = null;
+let myLidJid = null;
+export function getMyInfo() {
+    const normalizedJid = myJid ? myJid.replace(/:\d+@/, "@") : null;
+    return {
+        jid: normalizedJid,
+        lidJid: myLidJid,
+        name: myName || "You",
+        phone: normalizedJid ? fromJid(normalizedJid) : null,
+    };
+}
+function resetConnectionPromise() {
+    connectionReady = new Promise((resolve, reject) => {
+        resolveConnection = resolve;
+        rejectConnection = reject;
+    });
+}
+function scheduleReconnect(delayMs) {
+    reconnectAttempts++;
+    if (reconnectAttempts > MAX_RECONNECT_ATTEMPTS) {
+        console.error(`Fatal: reached MAX_RECONNECT_ATTEMPTS (${MAX_RECONNECT_ATTEMPTS}). ` +
+            "Stopping reconnect attempts.");
+        return;
+    }
+    if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+    }
+    console.error(`Reconnecting in ${delayMs / 1000}s (attempt ${reconnectAttempts})...`);
+    resetConnectionPromise();
+    reconnectTimer = setTimeout(() => {
+        reconnectTimer = null;
+        void initWhatsApp();
+    }, delayMs);
+}
+function clearZombieWatchdog() {
+    if (!zombieWatchdog)
+        return;
+    clearInterval(zombieWatchdog);
+    zombieWatchdog = null;
+}
+function startZombieWatchdog(currentSock) {
+    clearZombieWatchdog();
+    const checkIntervalMs = Math.max(1000, Math.min(10000, ZOMBIE_TIMEOUT_MS));
+    zombieWatchdog = setInterval(() => {
+        if (!sock || sock !== currentSock)
+            return;
+        if (Date.now() - lastConnectionActivity < ZOMBIE_TIMEOUT_MS)
+            return;
+        clearZombieWatchdog();
+        currentSock.end(new Error("Zombie connection detected"));
+    }, checkIntervalMs);
+}
+async function sendMessageWithHealthCheck(currentSock, jid, messageContent) {
+    await sendRateLimiter.throttle();
+    try {
+        const result = await currentSock.sendMessage(jid, messageContent);
+        consecutiveSendFailures = 0;
+        return result;
+    }
+    catch (err) {
+        consecutiveSendFailures++;
+        if (consecutiveSendFailures >= MAX_SEND_FAILURES) {
+            currentSock.end(new Error("Send health check failed"));
+        }
+        throw err;
+    }
+}
+export async function clearAuthState() {
+    try {
+        const entries = await fs.promises.readdir(AUTH_DIR);
+        await Promise.all(entries.map((entry) => fs.promises.rm(path.join(AUTH_DIR, entry), { recursive: true, force: true })));
+    }
+    catch (err) {
+        if (err?.code === "ENOENT")
+            return;
+        console.error("Failed to clear auth state:", err);
+    }
+}
+async function prunePreKeys(authDir) {
+    const files = await fs.promises.readdir(authDir).catch(() => []);
+    const preKeyFiles = files.filter(f => f.startsWith('pre-key-') || f.startsWith('sender-key-') || f.startsWith('session-'));
+    if (preKeyFiles.length > PRE_KEY_MAX_FILES) {
+        const withStats = await Promise.all(preKeyFiles.map(async (f) => ({
+            f,
+            mtime: (await fs.promises.stat(path.join(authDir, f)).catch(() => ({ mtimeMs: 0 }))).mtimeMs,
+        })));
+        withStats.sort((a, b) => a.mtime - b.mtime);
+        const toDelete = withStats.slice(0, withStats.length - PRE_KEY_KEEP_FILES);
+        await Promise.all(toDelete.map(({ f }) => fs.promises.unlink(path.join(authDir, f)).catch(() => { })));
+        console.error(`Pruned ${toDelete.length} pre-key/session files (${preKeyFiles.length} -> ${PRE_KEY_KEEP_FILES})`);
+    }
+}
+export function getReconnectAttempts() {
+    return reconnectAttempts;
+}
+export async function handleDisconnect(statusCode, currentSock) {
+    const socketState = currentSock ? "socket-present" : "socket-missing";
+    console.error(`Connection closed. Status: ${statusCode}. Context: ${socketState}`);
+    switch (statusCode) {
+        case DisconnectReason.loggedOut: {
+            await clearAuthState();
+            console.error("WhatsApp logged out. re-scan QR required.");
+            rejectConnection(new Error("Logged out from WhatsApp. re-scan QR required."));
+            return;
+        }
+        case DisconnectReason.forbidden: {
+            console.error("Disconnect forbidden (403). Reconnect disabled.");
+            rejectConnection(new Error("WhatsApp connection forbidden (403)."));
+            return;
+        }
+        case DisconnectReason.multideviceMismatch: {
+            console.error("Multi-device mismatch (411). Please update Baileys.");
+            rejectConnection(new Error("Multi-device mismatch (411). update Baileys."));
+            return;
+        }
+        case DisconnectReason.connectionLost:
+        case DisconnectReason.connectionClosed:
+        case DisconnectReason.unavailableService: {
+            const delay = Math.min(1000 * 2 ** (reconnectAttempts + 1), 30000);
+            scheduleReconnect(delay);
+            return;
+        }
+        case DisconnectReason.connectionReplaced: {
+            console.error("Connection replaced by another session. " +
+                "If this keeps happening, delete auth_info/ and re-scan the QR code.");
+            const rejectCurrentConnection = rejectConnection;
+            resetConnectionPromise();
+            rejectCurrentConnection(new Error("Connection replaced by another session."));
+            const delay = Math.min(10000 * 2 ** reconnectAttempts, 30000);
+            scheduleReconnect(delay);
+            return;
+        }
+        case DisconnectReason.badSession: {
+            await clearAuthState();
+            console.error("Bad session (500). Clearing auth state and reconnecting.");
+            const delay = Math.min(1000 * 2 ** (reconnectAttempts + 1), 30000);
+            scheduleReconnect(delay);
+            return;
+        }
+        case DisconnectReason.restartRequired: {
+            scheduleReconnect(0);
+            return;
+        }
+        default: {
+            console.error(`Unknown disconnect code: ${statusCode}. Reconnecting with backoff.`);
+            const delay = Math.min(1000 * 2 ** (reconnectAttempts + 1), 30000);
+            scheduleReconnect(delay);
+            return;
+        }
+    }
+}
+resetConnectionPromise();
+/**
+ * Mark connection as ready without connecting to WhatsApp.
+ * Used when another instance owns the connection and this one reads from SQLite only.
+ */
+export function resolveConnectionAsReadOnly() {
+    resolveConnection();
+}
+/**
+ * Initialize the Baileys WhatsApp client.
+ * QR codes are printed to stderr so they don't interfere with MCP stdio.
+ */
+export async function initWhatsApp() {
+    clearZombieWatchdog();
+    // Prune stale pre-key/session files on startup
+    await prunePreKeys(AUTH_DIR);
+    // Schedule periodic pre-key pruning (every 6 hours)
+    if (!preKeyPruneInterval) {
+        preKeyPruneInterval = setInterval(() => void prunePreKeys(AUTH_DIR), PRE_KEY_PRUNE_INTERVAL_MS);
+    }
+    if (sock) {
+        await flushPendingWrites();
+        sock.ev.removeAllListeners();
+        sock.end(undefined);
+        sock = null;
+    }
+    const { state, saveCreds } = await useAtomicMultiFileAuthState(AUTH_DIR);
+    const { version } = await fetchLatestBaileysVersion();
+    // Only request full history sync on first pairing (when no creds exist yet).
+    // On reconnections, history won't be sent by WhatsApp anyway, and requesting
+    // it causes Baileys to enter AwaitingInitialSync for 20s before timing out —
+    // which leads to 408 disconnects and an endless reconnect loop.
+    const isFirstPairing = !state.creds.registered;
+    // Wrap keys.set so every auth-state write is tracked and can be awaited
+    // before socket close — preventing stale session files on disk.
+    const originalKeysSet = state.keys.set.bind(state.keys);
+    state.keys.set = (data) => {
+        const result = originalKeysSet(data);
+        // keys.set returns Awaitable<void> — may be sync or async
+        if (result && typeof result.then === "function") {
+            const p = result.catch((err) => {
+                console.error("Auth key write failed:", err);
+            });
+            return trackWrite(p);
+        }
+        return result;
+    };
+    const trackedSaveCreds = () => trackWrite(saveCreds());
+    sock = makeWASocket({
+        version,
+        auth: state,
+        logger,
+        printQRInTerminal: false,
+        browser: ["WhatsApp MCP", "Chrome", "1.0.0"],
+        generateHighQualityLinkPreview: false,
+        syncFullHistory: isFirstPairing,
+        shouldSyncHistoryMessage: () => isFirstPairing,
+        keepAliveIntervalMs: 25_000,
+        markOnlineOnConnect: false,
+        msgRetryCounterCache: new NodeCache({ stdTTL: 60, maxKeys: 500 }),
+        userDevicesCache: new NodeCache({ stdTTL: 300, maxKeys: 1000 }),
+    });
+    lastConnectionActivity = Date.now();
+    consecutiveSendFailures = 0;
+    startZombieWatchdog(sock);
+    // ─── Bind events ──────────────────────────────────────────
+    //
+    // CRITICAL: We must use sock.ev.process() instead of individual sock.ev.on()
+    // listeners. Baileys buffers events during history sync and flushes them as a
+    // consolidated map via the internal 'event' emitter. Individual .on() listeners
+    // only receive unbuffered events and will MISS the entire history sync payload.
+    // sock.ev.process() is the correct API that receives both buffered and unbuffered events.
+    sock.ev.on("creds.update", trackedSaveCreds);
+    sock.ev.process(async (events) => {
+        // ─── Connection Updates ─────────────────────────────────
+        if (events["connection.update"]) {
+            lastConnectionActivity = Date.now();
+            const { connection, lastDisconnect, qr } = events["connection.update"];
+            if (qr) {
+                console.error("\n=== Scan this QR code in WhatsApp ===");
+                console.error("Link a device > QR code\n");
+                printQrToStderr(qr);
+            }
+            if (connection === "close") {
+                clearZombieWatchdog();
+                const statusCode = lastDisconnect?.error?.output?.statusCode;
+                await handleDisconnect(statusCode, sock);
+            }
+            if (connection === "open") {
+                console.error("WhatsApp connected successfully!");
+                reconnectAttempts = 0;
+                lastConnectionActivity = Date.now();
+                consecutiveSendFailures = 0;
+                if (sock?.user) {
+                    myJid = sock.user.id;
+                    myName = sock.user.name || null;
+                    myLidJid = sock.user.lid || null;
+                    // Normalize JID: strip device suffix (e.g. "971525527198:5@s.whatsapp.net" → "971525527198@s.whatsapp.net")
+                    const normalizedJid = myJid.replace(/:\d+@/, "@");
+                    const displayName = myName || "You";
+                    console.error(`Authenticated as: ${displayName} (${normalizedJid}${myLidJid ? `, LID: ${myLidJid}` : ""})`);
+                    // Store our own identity so our chat shows a name, not a number
+                    db.upsertContact(normalizedJid, displayName, myName);
+                    db.upsertChat(normalizedJid, displayName, null, null);
+                    // Store LID ↔ phone mapping for our own account
+                    if (myLidJid) {
+                        db.saveJidMapping(myLidJid, normalizedJid);
+                        db.upsertContact(myLidJid, displayName, myName);
+                        db.upsertChat(myLidJid, displayName, null, null);
+                    }
+                }
+                console.error("Connection ready");
+                resolveConnection();
+            }
+        }
+        // ─── History Sync (bulk load after QR scan) ─────────────
+        if (events["messaging-history.set"]) {
+            const { chats: syncChats, contacts: syncContacts, messages: syncMessages } = events["messaging-history.set"];
+            const progress = events["messaging-history.set"].progress;
+            const syncType = events["messaging-history.set"].syncType;
+            console.error(`History sync: ${syncChats.length} chats, ${syncContacts.length} contacts, ${syncMessages.length} messages (type=${syncType} progress=${progress ?? "?"}%)`);
+            db.upsertChats(syncChats);
+            db.upsertContacts(syncContacts);
+            // Propagate contact names (push names) to the chats table so chat
+            // listings show names immediately. The push_name sync (type 4)
+            // delivers ~1000 contacts with notify fields — without this step
+            // those names only exist in the contacts table and require a JOIN.
+            // Also extract LID ↔ phone JID mappings from synced contacts.
+            for (const contact of syncContacts) {
+                const displayName = contact.name || contact.notify || contact.verifiedName;
+                if (displayName && contact.id) {
+                    db.upsertChat(contact.id, displayName, null, null);
+                }
+                // Extract LID ↔ phone mapping
+                const cLid = contact.lid || (contact.id?.endsWith?.("@lid") ? contact.id : null);
+                const cPhone = contact.jid || (contact.id?.endsWith?.("@s.whatsapp.net") ? contact.id : null);
+                if (cLid && cPhone) {
+                    db.saveJidMapping(cLid, cPhone);
+                }
+            }
+            // Group messages by chat JID and batch-insert
+            const byJid = new Map();
+            for (const msg of syncMessages) {
+                const jid = msg.key.remoteJid;
+                if (!jid)
+                    continue;
+                if (!byJid.has(jid))
+                    byJid.set(jid, []);
+                byJid.get(jid).push(msg);
+            }
+            for (const [jid, msgs] of byJid) {
+                db.upsertMessages(jid, msgs);
+                if (msgs.length > 0) {
+                    const latest = msgs[msgs.length - 1];
+                    db.upsertChat(jid, null, Number(latest.messageTimestamp || 0), 0);
+                }
+            }
+        }
+        // ─── Chat Events ────────────────────────────────────────
+        if (events["chats.upsert"]) {
+            db.upsertChats(events["chats.upsert"]);
+        }
+        if (events["chats.update"]) {
+            for (const update of events["chats.update"]) {
+                if (!update.id)
+                    continue;
+                db.upsertChat(update.id, update.name, update.conversationTimestamp ? Number(update.conversationTimestamp) : null, update.unreadCount);
+            }
+        }
+        if (events["chats.delete"]) {
+            for (const id of events["chats.delete"]) {
+                db.deleteChat(id);
+            }
+        }
+        // ─── LID ↔ Phone JID Mapping ────────────────────────────
+        if (events["chats.phoneNumberShare"]) {
+            const { lid, jid } = events["chats.phoneNumberShare"];
+            if (lid && jid) {
+                db.saveJidMapping(lid, jid);
+            }
+        }
+        // ─── Contact Events ─────────────────────────────────────
+        if (events["contacts.upsert"]) {
+            const contacts = events["contacts.upsert"];
+            db.upsertContacts(contacts);
+            for (const contact of contacts) {
+                const name = contact.name || contact.notify;
+                if (name) {
+                    // Store under the primary id
+                    db.upsertChat(contact.id, name, null, null);
+                    // ContactAction from app state sync may use LID as id but provide
+                    // the phone-number JID in the jid field — store under that too
+                    const phoneJid = contact.jid;
+                    if (phoneJid && phoneJid !== contact.id) {
+                        db.upsertContact(phoneJid, contact.name || null, contact.notify || null);
+                        db.upsertChat(phoneJid, name, null, null);
+                    }
+                }
+                // Extract LID ↔ phone JID mapping from Contact object.
+                // Baileys Contact type has: id (primary), lid? (@lid), jid? (@s.whatsapp.net)
+                const cLid = contact.lid || (contact.id.endsWith("@lid") ? contact.id : null);
+                const cPhone = contact.jid || (contact.id.endsWith("@s.whatsapp.net") ? contact.id : null);
+                if (cLid && cPhone) {
+                    db.saveJidMapping(cLid, cPhone);
+                }
+            }
+        }
+        if (events["contacts.update"]) {
+            for (const update of events["contacts.update"]) {
+                if (!update.id)
+                    continue;
+                db.upsertContact(update.id, update.name, update.notify);
+                const updatedName = update.name || update.notify;
+                if (updatedName) {
+                    db.upsertChat(update.id, updatedName, null, null);
+                }
+            }
+        }
+        // ─── Message Events ─────────────────────────────────────
+        if (events["messages.upsert"]) {
+            const { messages: newMsgs } = events["messages.upsert"];
+            for (const msg of newMsgs) {
+                const jid = msg.key.remoteJid;
+                if (!jid)
+                    continue;
+                // pushName is the sender's WhatsApp display name — use it to populate contacts
+                const pushName = msg.pushName;
+                const senderJid = msg.key.fromMe ? null : (msg.key.participant || jid);
+                if (pushName && senderJid) {
+                    db.upsertContact(senderJid, null, pushName);
+                }
+                db.upsertMessage(jid, msg);
+                const msgTs = Number(msg.messageTimestamp || 0);
+                const chatName = (!msg.key.fromMe && !jid.endsWith("@g.us") && pushName) ? pushName : null;
+                db.upsertChat(jid, chatName, msgTs, msg.key.fromMe ? null : undefined);
+            }
+        }
+        if (events["messages.update"]) {
+            for (const { key, update } of events["messages.update"]) {
+                const jid = key.remoteJid;
+                if (!jid || !key.id)
+                    continue;
+                const merged = { key, message: update.message, messageTimestamp: update.messageTimestamp, participant: update.participant };
+                if (merged.message) {
+                    db.upsertMessage(jid, merged);
+                }
+            }
+        }
+    });
+}
+/**
+ * Cleanly close the WhatsApp connection.
+ */
+export async function closeWhatsApp() {
+    clearZombieWatchdog();
+    if (preKeyPruneInterval) {
+        clearInterval(preKeyPruneInterval);
+        preKeyPruneInterval = null;
+    }
+    if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+    }
+    if (sock) {
+        await flushPendingWrites();
+        sock.ev.removeAllListeners();
+        sock.end(undefined);
+        sock = null;
+    }
+}
+/**
+ * Resolve a chat name. For groups without a name, fetch metadata from WhatsApp.
+ * Like the Go project's GetChatName — resolve inline when needed.
+ */
+async function resolveChatName(jid) {
+    // Check if we already have a name in the DB
+    const existing = db.getChatName(jid);
+    if (existing)
+        return existing;
+    // For groups, try fetching metadata
+    if (jid.endsWith("@g.us") && sock) {
+        try {
+            const meta = await sock.groupMetadata(jid);
+            if (meta.subject) {
+                db.upsertChat(jid, meta.subject, null, null);
+                return meta.subject;
+            }
+        }
+        catch {
+            // Group may no longer exist or we're not a member
+        }
+    }
+    // For individual chats, try contact store
+    if (jid.endsWith("@s.whatsapp.net")) {
+        const contact = db.getContactName(jid);
+        if (contact) {
+            db.upsertChat(jid, contact, null, null);
+            return contact;
+        }
+    }
+    return null;
+}
+async function getSocket() {
+    // During reconnection cycles, sock may be momentarily null while a new
+    // socket is being created. Re-await connectionReady to wait for it.
+    if (!sock) {
+        await connectionReady;
+    }
+    if (!sock)
+        throw new Error("WhatsApp socket not available. This instance is running in read-only mode " +
+            "(another MCP server process owns the WhatsApp connection). " +
+            "This operation requires an active WhatsApp connection. Try restarting Claude Desktop, " +
+            "or delete the lock file at store/.whatsapp.lock if the other process is dead.");
+    return sock;
+}
+/**
+ * Return the socket if available, or null if running in read-only mode.
+ * Used by media download functions that can work without a socket —
+ * the socket is only needed as a fallback to re-upload expired CDN URLs.
+ */
+function getSocketOrNull() {
+    return sock;
+}
+// ─── Reading Functions ──────────────────────────────────────────────
+export async function getChats(nameFilter, limit) {
+    await connectionReady;
+    const chats = db.getChats(nameFilter, limit);
+    // Resolve names for any chats missing them (like the Go project does inline)
+    for (const chat of chats) {
+        if (!chat.name && typeof chat.jid === "string") {
+            const name = await resolveChatName(chat.jid);
+            if (name)
+                chat.name = name;
+        }
+    }
+    return chats;
+}
+export async function getChat(jid) {
+    await connectionReady;
+    const normalJid = toJid(jid);
+    const chat = db.getChat(normalJid);
+    // Resolve name if missing
+    if (chat && !chat.name) {
+        const name = await resolveChatName(normalJid);
+        if (name)
+            chat.name = name;
+    }
+    return chat;
+}
+export async function getMessages(jid, limit = 50) {
+    await connectionReady;
+    return db.getMessages(toJid(jid), limit);
+}
+export async function searchMessages(query, jid) {
+    await connectionReady;
+    return db.searchMessages(query, jid ? toJid(jid) : undefined);
+}
+export async function searchContacts(query) {
+    await connectionReady;
+    return db.searchContacts(query);
+}
+export async function getMessageContext(jid, messageId, count = 5) {
+    await connectionReady;
+    return db.getMessageContext(toJid(jid), messageId, count);
+}
+// ─── Contact Management ─────────────────────────────────────────────
+export async function updateContact(jid, name) {
+    const normalJid = toJid(jid);
+    db.upsertContact(normalJid, name, null);
+    db.upsertChat(normalJid, name, null, null);
+    return { success: true, jid: normalJid, name };
+}
+// ─── Writing Functions ──────────────────────────────────────────────
+export async function deleteChat(jid) {
+    await connectionReady;
+    const s = await getSocket();
+    const normalJid = toJid(jid);
+    const lastMsg = db.getLastMessageKey(normalJid);
+    if (!lastMsg) {
+        throw new Error(`No messages found in chat ${normalJid} — cannot delete an empty chat.`);
+    }
+    try {
+        await s.chatModify({
+            delete: true,
+            lastMessages: [{
+                    key: {
+                        remoteJid: normalJid,
+                        fromMe: lastMsg.fromMe,
+                        id: lastMsg.id,
+                    },
+                    messageTimestamp: lastMsg.timestamp,
+                }],
+        }, normalJid);
+    }
+    catch (err) {
+        if (err.message?.includes("not present")) {
+            throw new Error("WhatsApp app state keys haven't synced yet. " +
+                "This happens on fresh installs — wait a few minutes and try again, or restart the server.");
+        }
+        throw err;
+    }
+    // Clean up local database
+    db.deleteChatMessages(normalJid);
+    db.deleteChat(normalJid);
+    return { success: true, jid: normalJid };
+}
+export async function deleteMessage(jid, messageId) {
+    await connectionReady;
+    const s = await getSocket();
+    const normalJid = toJid(jid);
+    // Look up from_me to build the correct WAMessageKey for deletion
+    const fromMe = db.getMessageFromMe(normalJid, messageId);
+    if (fromMe === null) {
+        throw new Error(`Message ${messageId} not found in chat ${normalJid}`);
+    }
+    // Delete on WhatsApp servers first — if this fails, local DB stays intact
+    await sendMessageWithHealthCheck(s, normalJid, {
+        delete: {
+            remoteJid: normalJid,
+            fromMe,
+            id: messageId,
+        },
+    });
+    // Remove from local database
+    db.deleteMessage(normalJid, messageId);
+    return { success: true, jid: normalJid, messageId };
+}
+export function getRecipientInfo(jid) {
+    const normalJid = toJid(jid);
+    const name = db.getContactName(normalJid);
+    const phone = fromJid(normalJid);
+    return { jid: normalJid, name, phone };
+}
+export async function sendTextMessage(jid, text) {
+    await connectionReady;
+    const s = await getSocket();
+    const normalJid = toJid(jid);
+    const sent = await sendMessageWithHealthCheck(s, normalJid, { text });
+    return {
+        success: true,
+        messageId: sent?.key.id,
+        to: normalJid,
+    };
+}
+export async function sendFileMessage(jid, filePath, caption) {
+    const allowedDir = process.env.ALLOWED_SEND_DIR || "./uploads/";
+    const maxFileSize = Number(process.env.MAX_SEND_FILE_SIZE || "67108864");
+    const validation = validateFilePath(filePath, allowedDir, maxFileSize);
+    if (!validation.valid) {
+        throw new Error(validation.error);
+    }
+    const absolutePath = validation.absolutePath;
+    await connectionReady;
+    const s = await getSocket();
+    const normalJid = toJid(jid);
+    const mime = mimeFromExtension(absolutePath);
+    const category = mediaCategoryFromMime(mime);
+    const stream = fs.createReadStream(absolutePath);
+    const fileName = path.basename(absolutePath);
+    let messageContent;
+    switch (category) {
+        case "image":
+            messageContent = { image: stream, caption, mimetype: mime };
+            break;
+        case "video":
+            messageContent = { video: stream, caption, mimetype: mime };
+            break;
+        case "audio":
+            messageContent = { audio: stream, mimetype: mime, ptt: false };
+            break;
+        default:
+            messageContent = { document: stream, mimetype: mime, fileName, caption };
+            break;
+    }
+    const sent = await sendMessageWithHealthCheck(s, normalJid, messageContent);
+    return {
+        success: true,
+        messageId: sent?.key.id,
+        to: normalJid,
+        fileType: category,
+    };
+}
+// ─── Media Functions ────────────────────────────────────────────────
+export async function downloadMessageMedia(jid, messageId) {
+    await connectionReady;
+    const normalJid = toJid(jid);
+    const blob = db.getMessageBlob(normalJid, messageId);
+    if (!blob) {
+        throw new Error(`Message ${messageId} not found or has no downloadable media in chat ${normalJid}`);
+    }
+    const stored = JSON.parse(blob);
+    if (!stored.message) {
+        throw new Error("Message has no content");
+    }
+    const s = getSocketOrNull();
+    const buffer = await downloadMediaMessage(stored, "buffer", {}, s ? { logger, reuploadRequest: s.updateMediaMessage } : undefined);
+    const contentType = getContentType(stored.message);
+    const mediaMsg = stored.message[contentType];
+    const mimetype = mediaMsg?.mimetype || "application/octet-stream";
+    const ext = extensionFromMime(mimetype);
+    fs.mkdirSync(DOWNLOADS_DIR, { recursive: true });
+    const fileName = `${sanitizeFilename(messageId)}.${ext}`;
+    const outPath = path.join(DOWNLOADS_DIR, fileName);
+    if (!path.resolve(outPath).startsWith(path.resolve(DOWNLOADS_DIR) + path.sep)) {
+        throw new Error("Path traversal detected");
+    }
+    fs.writeFileSync(outPath, buffer);
+    return {
+        success: true,
+        filePath: path.resolve(outPath),
+        fileName,
+        mimeType: mimetype,
+        type: contentType,
+        size: buffer.length,
+    };
+}
+export async function transcribeVoiceNote(jid, messageId) {
+    await connectionReady;
+    const normalJid = toJid(jid);
+    // Validate message type
+    const msgType = db.getMessageTypeById(normalJid, messageId);
+    if (!msgType) {
+        throw new Error(`Message ${messageId} not found in chat ${normalJid}`);
+    }
+    if (msgType !== "voice_note" && msgType !== "audio") {
+        throw new Error(`Message ${messageId} is type "${msgType}", not a voice note or audio message.`);
+    }
+    // Check cache
+    const cached = db.getTranscription(normalJid, messageId);
+    if (cached) {
+        return {
+            success: true,
+            messageId,
+            chatJid: normalJid,
+            transcription: cached,
+            cached: true,
+        };
+    }
+    // Download audio into RAM (no disk write)
+    const blob = db.getMessageBlob(normalJid, messageId);
+    if (!blob) {
+        throw new Error(`Message ${messageId} has no downloadable media`);
+    }
+    const stored = JSON.parse(blob);
+    if (!stored.message) {
+        throw new Error("Message has no content");
+    }
+    const s = getSocketOrNull();
+    const buffer = await downloadMediaMessage(stored, "buffer", {}, s ? { logger, reuploadRequest: s.updateMediaMessage } : undefined);
+    const contentType = getContentType(stored.message);
+    const mediaMsg = stored.message[contentType];
+    const ext = extensionFromMime(mediaMsg?.mimetype || "audio/ogg");
+    // Transcribe via Whisper API
+    const result = await transcribeAudio(buffer, `${messageId}.${ext}`);
+    // Cache in database
+    db.saveTranscription(normalJid, messageId, result.text);
+    return {
+        success: true,
+        messageId,
+        chatJid: normalJid,
+        transcription: result.text,
+        language: result.language,
+        duration: result.duration,
+        cached: false,
+    };
+}
+function extensionFromMime(mime) {
+    const map = {
+        "image/jpeg": "jpg",
+        "image/png": "png",
+        "image/gif": "gif",
+        "image/webp": "webp",
+        "video/mp4": "mp4",
+        "audio/ogg; codecs=opus": "ogg",
+        "audio/ogg": "ogg",
+        "audio/mpeg": "mp3",
+        "audio/mp4": "m4a",
+        "application/pdf": "pdf",
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "xlsx",
+    };
+    return map[mime] || mime.split("/").pop()?.replace(/[^a-z0-9]/g, "") || "bin";
+}
+// ─── QR Code Rendering ─────────────────────────────────────────────
+function printQrToStderr(qr) {
+    // @ts-ignore - qrcode-terminal has no types
+    import("qrcode-terminal").then((mod) => {
+        const QRC = mod.default || mod;
+        QRC.generate(qr, { small: true }, (code) => {
+            console.error(code);
+        });
+    }).catch(() => {
+        console.error("QR Data (copy to a QR code generator):");
+        console.error(qr);
+    });
+}
+//# sourceMappingURL=whatsapp.js.map