elevenlabs-webhook-nodejs 1.0.0

package/baileys/worker.js

@@ -0,0 +1,721 @@
+/**
+ * Baileys Worker Process
+ *
+ * Runs a single Baileys WhatsApp socket in an isolated child process.
+ * Communicates with the gateway (server.js) via IPC (process.send / process.on).
+ *
+ * Auth state is stored in MongoDB (shared across all workers via MONGODB_URI).
+ * Falls back to local file auth if MONGODB_URI is not set.
+ *
+ * IPC Protocol — Worker → Parent:
+ *   { type: 'qr', qr }
+ *   { type: 'connected', phone }
+ *   { type: 'disconnected', reason }
+ *   { type: 'logged_out' }
+ *   { type: 'status', status }
+ *   { type: 'message', payload }              — Unipile-format webhook payload
+ *   { type: 'reply', reqId, data }            — Response to a request
+ *   { type: 'reply', reqId, error }           — Error response
+ *   { type: 'ready' }                         — Worker initialized
+ *
+ * IPC Protocol — Parent → Worker:
+ *   { type: 'init', accountId, authDir, mongodbUri }
+ *   { type: 'send', chatId, text, reqId }
+ *   { type: 'start_chat', phone, text, reqId }
+ *   { type: 'forward_media', messageId, toPhone, caption, reqId }
+ *   { type: 'disconnect' }
+ */
+
+import makeWASocket, {
+  useMultiFileAuthState,
+  DisconnectReason,
+  Browsers,
+  fetchLatestBaileysVersion,
+  makeCacheableSignalKeyStore,
+  isJidBroadcast,
+  isJidGroup,
+  isLidUser,
+  getContentType,
+  jidNormalizedUser,
+  downloadMediaMessage,
+} from '@whiskeysockets/baileys';
+import { MongoClient } from 'mongodb';
+import pino from 'pino';
+import { jidToPhone, phoneFromSockUser, extractText, MEDIA_PLACEHOLDER, MEDIA_TYPE_LABELS } from './src/utils/jid.js';
+import { useMongoDBAuthState, deleteMongoDBAuthState } from './src/utils/use-mongodb-auth-state.js';
+
+const workerLogger = pino({ level: 'warn' });
+
+let sock = null;
+let accountId = null;
+let authDir = null;
+let mongodbUri = null;
+let mongoClient = null;
+let mongoDb = null;
+let connectedPhone = null;
+let mediaForwardTo = null;
+
+// ─── Media Message Cache ────────────────────────────────
+// Caches recent media messages so we can re-download them for forwarding.
+// downloadMediaMessage() requires the original Baileys message object (with encryption keys).
+const messageCache = new Map(); // key: messageId, value: { msg, contentType, timestamp }
+const MESSAGE_CACHE_TTL_MS = 60 * 60 * 1000; // 60 minutes
+
+function cleanMessageCache() {
+  const now = Date.now();
+  for (const [key, entry] of messageCache) {
+    if (now - entry.timestamp > MESSAGE_CACHE_TTL_MS) {
+      messageCache.delete(key);
+    }
+  }
+}
+
+// Clean cache every 5 minutes
+setInterval(cleanMessageCache, 5 * 60 * 1000);
+
+function send(msg) {
+  if (process.send) process.send(msg);
+}
+
+/**
+ * Extract ad attribution from contextInfo for the webhook payload.
+ * Returns null if the message didn't come from an ad click.
+ */
+function sanitizeAdContext(ctx) {
+  if (!ctx.externalAdReply && !ctx.entryPointConversionSource) return null;
+
+  const clean = {};
+
+  if (ctx.externalAdReply) {
+    const ad = ctx.externalAdReply;
+    clean.ad = {
+      title: ad.title || null,
+      body: ad.body || null,
+      source_url: ad.sourceUrl || null,
+    };
+  }
+
+  if (ctx.entryPointConversionSource) clean.source = ctx.entryPointConversionSource;
+  if (ctx.entryPointConversionApp) clean.app = ctx.entryPointConversionApp;
+
+  return clean;
+}
+
+/**
+ * Strip binary/heavy fields from contextInfo for logging.
+ * Keeps: externalAdReply, quotedMessage (text-only summary), mentionedJid,
+ *        isForwarded, forwardingScore, entryPointConversion* fields.
+ */
+function sanitizeContextInfo(ctx) {
+  const clean = {};
+
+  if (ctx.externalAdReply) {
+    const ad = ctx.externalAdReply;
+    clean.externalAdReply = {
+      title: ad.title || null,
+      body: ad.body || null,
+      mediaUrl: ad.mediaUrl || null,
+      sourceUrl: ad.sourceUrl || null,
+      mediaType: ad.mediaType ?? null,
+      showAdAttribution: ad.showAdAttribution ?? null,
+    };
+  }
+
+  if (ctx.quotedMessage) {
+    // Only store text summary, not the full nested message proto
+    const qm = ctx.quotedMessage;
+    clean.quotedMessage = {
+      text: qm.conversation || qm.extendedTextMessage?.text || qm.imageMessage?.caption || null,
+      type: qm.conversation ? 'conversation' : Object.keys(qm)[0] || null,
+    };
+    if (ctx.stanzaId) clean.quotedStanzaId = ctx.stanzaId;
+    if (ctx.participant) clean.quotedParticipant = ctx.participant;
+  }
+
+  if (ctx.mentionedJid?.length) clean.mentionedJid = ctx.mentionedJid;
+  if (ctx.isForwarded) clean.isForwarded = true;
+  if (ctx.forwardingScore) clean.forwardingScore = ctx.forwardingScore;
+  if (ctx.entryPointConversionSource) clean.entryPointConversionSource = ctx.entryPointConversionSource;
+  if (ctx.entryPointConversionApp) clean.entryPointConversionApp = ctx.entryPointConversionApp;
+  if (ctx.entryPointConversionDelaySeconds) clean.entryPointConversionDelaySeconds = ctx.entryPointConversionDelaySeconds;
+
+  return Object.keys(clean).length > 0 ? clean : null;
+}
+
+// ─── IPC Message Handler ─────────────────────────────────
+
+process.on('message', async (msg) => {
+  switch (msg.type) {
+    case 'init':
+      accountId = msg.accountId;
+      authDir = msg.authDir;
+      mongodbUri = msg.mongodbUri || '';
+      mediaForwardTo = msg.mediaForwardTo || '';
+      await connectSocket();
+      break;
+
+    case 'send':
+      await handleSend(msg);
+      break;
+
+    case 'start_chat':
+      await handleStartChat(msg);
+      break;
+
+    case 'forward_media':
+      await handleForwardMedia(msg);
+      break;
+
+    case 'send_image':
+      await handleSendImage(msg);
+      break;
+
+    case 'download_audio':
+      await handleDownloadAudio(msg);
+      break;
+
+    case 'disconnect':
+      await handleDisconnect();
+      break;
+
+    case 'shutdown':
+      await handleShutdown();
+      break;
+  }
+});
+
+// ─── Auth State ──────────────────────────────────────────
+
+async function getAuthState() {
+  if (mongodbUri) {
+    try {
+      mongoClient = new MongoClient(mongodbUri);
+      await mongoClient.connect();
+      // Verify connection works
+      await mongoClient.db().command({ ping: 1 });
+      mongoDb = mongoClient.db();
+      return useMongoDBAuthState(mongoDb, accountId);
+    } catch (err) {
+      // If URI has credentials and auth fails, try without credentials
+      try {
+        const url = new URL(mongodbUri);
+        if (url.username) {
+          url.username = '';
+          url.password = '';
+          const noAuthUri = url.toString();
+          if (mongoClient) try { await mongoClient.close(); } catch {}
+          mongoClient = new MongoClient(noAuthUri);
+          await mongoClient.connect();
+          await mongoClient.db().command({ ping: 1 });
+          mongoDb = mongoClient.db();
+          return useMongoDBAuthState(mongoDb, accountId);
+        }
+      } catch {}
+      // All MongoDB attempts failed, fall back to file auth
+      if (mongoClient) try { await mongoClient.close(); } catch {}
+      mongoClient = null;
+      mongoDb = null;
+    }
+  }
+
+  // Fallback to file-based auth
+  return useMultiFileAuthState(authDir);
+}
+
+// ─── Baileys Socket ──────────────────────────────────────
+
+async function connectSocket() {
+  try {
+    const { state, saveCreds } = await getAuthState();
+    const { version } = await fetchLatestBaileysVersion();
+
+    sock = makeWASocket({
+      version,
+      auth: {
+        creds: state.creds,
+        keys: makeCacheableSignalKeyStore(state.keys, workerLogger),
+      },
+      logger: workerLogger,
+      browser: Browsers.ubuntu('Portal'),
+      markOnlineOnConnect: false,
+      generateHighQualityLinkPreview: false,
+      syncFullHistory: false,
+      shouldSyncHistoryMessage: () => false,
+      connectTimeoutMs: 60_000,
+      qrTimeout: 40_000,
+    });
+
+    // ─── Connection Events ─────────────────────────────
+
+    sock.ev.on('connection.update', (update) => {
+      const { connection, lastDisconnect, qr } = update;
+
+      if (qr) {
+        send({ type: 'qr', qr });
+        send({ type: 'status', status: 'qr_pending' });
+      }
+
+      if (connection === 'connecting') {
+        send({ type: 'status', status: 'connecting' });
+      }
+
+      if (connection === 'open') {
+        connectedPhone = phoneFromSockUser(sock.user?.id);
+        send({ type: 'connected', phone: connectedPhone });
+        send({ type: 'status', status: 'connected' });
+      }
+
+      if (connection === 'close') {
+        const statusCode = lastDisconnect?.error?.output?.statusCode;
+        const reason = lastDisconnect?.error?.message || 'Unknown';
+
+        if (statusCode === DisconnectReason.loggedOut) {
+          // Clean auth state from MongoDB on logout
+          if (mongoDb) {
+            deleteMongoDBAuthState(mongoDb, accountId).catch(() => {});
+          }
+          send({ type: 'logged_out' });
+          send({ type: 'status', status: 'logged_out' });
+        } else {
+          send({ type: 'disconnected', reason, statusCode });
+          send({ type: 'status', status: 'disconnected' });
+          // Auto-reconnect after short delay
+          setTimeout(() => connectSocket(), 3_000);
+        }
+      }
+    });
+
+    // ─── Credentials ───────────────────────────────────
+
+    sock.ev.on('creds.update', saveCreds);
+
+    // ─── Incoming Messages ─────────────────────────────
+
+    sock.ev.on('messages.upsert', async ({ messages, type }) => {
+      // Helper to build base log entry from a message
+      function msgLogBase(msg) {
+        return {
+          messageId: msg.key?.id || null,
+          remoteJid: msg.key?.remoteJid || null,
+          fromMe: msg.key?.fromMe || false,
+          pushName: msg.pushName || null,
+          timestamp: msg.messageTimestamp
+            ? new Date(Number(msg.messageTimestamp) * 1000).toISOString()
+            : new Date().toISOString(),
+        };
+      }
+
+      function logFiltered(msg, reason, extra = {}) {
+        send({
+          type: 'message_log',
+          action: 'filtered',
+          reason,
+          ...msgLogBase(msg),
+          ...extra,
+        });
+      }
+
+      function logDispatched(msg, extra = {}) {
+        send({
+          type: 'message_log',
+          action: 'dispatched',
+          reason: null,
+          ...msgLogBase(msg),
+          ...extra,
+        });
+      }
+
+      if (type !== 'notify') {
+        // Log once for the whole batch
+        if (messages.length > 0) {
+          send({
+            type: 'message_log',
+            action: 'filtered',
+            reason: `not_notify:${type}`,
+            messageId: null,
+            remoteJid: null,
+            fromMe: false,
+            pushName: null,
+            timestamp: new Date().toISOString(),
+            batchSize: messages.length,
+          });
+        }
+        return;
+      }
+
+      for (const msg of messages) {
+        // Log raw WhatsApp message before any filtering
+        const rawContentType = msg.message ? getContentType(msg.message) : null;
+        const rawContextInfo = (rawContentType && msg.message?.[rawContentType]?.contextInfo) || null;
+        send({
+          type: 'raw_message',
+          key: msg.key,
+          messageStubType: msg.messageStubType || null,
+          pushName: msg.pushName || null,
+          messageTimestamp: msg.messageTimestamp || null,
+          contentType: rawContentType,
+          // Store message structure keys (not binary data) for debugging
+          messageKeys: msg.message ? Object.keys(msg.message) : [],
+          text: msg.message ? extractText(msg) : null,
+          // Store contextInfo for ad attribution, quoted messages, mentions etc.
+          // Strip binary fields (jpegThumbnail, thumbnailDirectPath) to keep logs lean
+          contextInfo: rawContextInfo ? sanitizeContextInfo(rawContextInfo) : null,
+        });
+
+        if (!msg.message) {
+          logFiltered(msg, 'no_message');
+          continue;
+        }
+        if (isJidBroadcast(msg.key.remoteJid)) {
+          logFiltered(msg, 'broadcast');
+          continue;
+        }
+        if (isJidGroup(msg.key.remoteJid)) {
+          logFiltered(msg, 'group_message');
+          continue;
+        }
+        if (msg.key.remoteJid === 'status@broadcast') {
+          logFiltered(msg, 'status_broadcast');
+          continue;
+        }
+
+        // Skip stub/system messages (encryption notifications, group events, etc.)
+        if (msg.messageStubType) {
+          logFiltered(msg, 'stub_message', { stubType: msg.messageStubType });
+          continue;
+        }
+
+        const contentType = getContentType(msg.message);
+
+        // Skip protocol and system content types — these are not user messages
+        const SKIP_CONTENT_TYPES = [
+          'protocolMessage',              // message edits, revokes, key changes
+          'senderKeyDistributionMessage', // encryption key distribution
+          'messageContextInfo',           // context metadata
+          'reactionMessage',              // emoji reactions
+          'pollUpdateMessage',            // poll vote updates
+          'pinInChatMessage',             // pin/unpin
+          'keepInChatMessage',            // keep messages
+          'encReactionMessage',           // encrypted reactions
+          'editedMessage',               // edited message container
+          'viewOnceMessageV2',           // view-once protocol wrapper
+          'viewOnceMessageV2Extension',
+          'eventMessage',                // calendar events
+          'newsletterAdminInviteMessage',
+          'messageHistoryBundle',        // history sync
+        ];
+        if (SKIP_CONTENT_TYPES.includes(contentType)) {
+          logFiltered(msg, 'skip_content_type', { contentType });
+          continue;
+        }
+
+        // Build Unipile-compatible webhook payload (1:1 chats only — groups filtered above)
+        const jid = msg.key.remoteJid;
+        const jidAlt = msg.key.remoteJidAlt || null;
+        const fromMe = msg.key.fromMe || false;
+
+        // Resolve LID to phone-based JID
+        // 1. Use remoteJidAlt if available (already in the message key)
+        // 2. Fall back to lidMapping lookup
+        let contactJid = jid;
+        if (isLidUser(contactJid)) {
+          if (jidAlt && !isLidUser(jidAlt)) {
+            contactJid = jidNormalizedUser(jidAlt);
+          } else if (sock.signalRepository?.lidMapping) {
+            try {
+              const pnJid = await sock.signalRepository.lidMapping.getPNForLID(contactJid);
+              if (pnJid) {
+                contactJid = jidNormalizedUser(pnJid);
+              }
+            } catch {}
+          }
+        }
+
+        // Resolve chat JID (same logic)
+        let chatJid = jidNormalizedUser(jid);
+        if (isLidUser(jid)) {
+          if (jidAlt && !isLidUser(jidAlt)) {
+            chatJid = jidNormalizedUser(jidAlt);
+          } else if (sock.signalRepository?.lidMapping) {
+            try {
+              const pnJid = await sock.signalRepository.lidMapping.getPNForLID(jid);
+              if (pnJid) {
+                chatJid = jidNormalizedUser(pnJid);
+              }
+            } catch {}
+          }
+        }
+
+        // Skip if all resolution attempts failed
+        if (isLidUser(contactJid)) {
+          logFiltered(msg, 'unresolved_lid', { contentType, contactJid });
+          continue;
+        }
+
+        const contactPhone = jidToPhone(contactJid);
+        const contactName = (!fromMe && msg.pushName) ? msg.pushName : contactPhone;
+
+        // Extract text or use media placeholder for non-text content
+        const text = extractText(msg);
+
+        // User-facing content types that contain actual messages
+        const textContentTypes = ['conversation', 'extendedTextMessage'];
+        const mediaContentTypes = [
+          'imageMessage', 'videoMessage', 'audioMessage', 'documentMessage',
+          'stickerMessage', 'contactMessage', 'contactsArrayMessage',
+          'locationMessage', 'liveLocationMessage',
+          'listMessage', 'listResponseMessage',
+          'buttonsMessage', 'buttonsResponseMessage',
+          'templateMessage', 'templateButtonReplyMessage',
+          'interactiveMessage', 'interactiveResponseMessage',
+          'pollCreationMessage', 'pollCreationMessageV3',
+          'orderMessage', 'productMessage',
+          'requestPhoneNumberMessage',
+          'albumMessage', 'stickerPackMessage',
+        ];
+
+        const isMediaMsg = mediaContentTypes.includes(contentType);
+        const mediaLabel = MEDIA_TYPE_LABELS[contentType] || MEDIA_PLACEHOLDER;
+        // For media with caption: prepend label so AI knows the type
+        // For media without caption: just the label
+        // For text-only: just the text
+        const messageText = isMediaMsg
+          ? (text ? `${mediaLabel} ${text}` : mediaLabel)
+          : (text || '');
+
+        if (!messageText) {
+          logFiltered(msg, 'empty_text', { contentType });
+          continue;
+        }
+
+        // Cache media messages for on-demand forwarding (operator workflow)
+        // Cache both incoming and outgoing media (operator may reply with documents from same device)
+        if (isMediaMsg) {
+          messageCache.set(msg.key.id, { msg, contentType, timestamp: Date.now() });
+        }
+
+        // Forward media messages to dev number for inspection
+        if (isMediaMsg && !fromMe && mediaForwardTo && sock) {
+          const forwardJid = mediaForwardTo.replace(/[^0-9]/g, '') + '@s.whatsapp.net';
+          forwardMedia(msg, contentType, forwardJid, contactName, contactPhone);
+        }
+
+        const timestamp = msg.messageTimestamp
+          ? new Date(Number(msg.messageTimestamp) * 1000).toISOString()
+          : new Date().toISOString();
+
+        const payload = {
+          account_id: accountId,
+          account_type: 'WHATSAPP',
+          event: 'message_received',
+          chat_id: `${accountId}:${chatJid}`,
+          message_id: msg.key.id,
+          message: messageText,
+          content_type: contentType,
+          timestamp,
+          is_sender: fromMe,
+          is_event: false,
+          hidden: false,
+          sender: {
+            attendee_id: contactPhone,
+            attendee_name: contactName,
+            attendee_provider_id: contactPhone,
+            attendee_specifics: { phone_number: contactPhone },
+          },
+          attendees: [{
+            attendee_id: contactPhone,
+            attendee_name: contactName,
+            attendee_provider_id: contactPhone,
+            attendee_specifics: { phone_number: contactPhone },
+          }],
+          account_info: {
+            type: 'WHATSAPP',
+            phone_number: connectedPhone || '',
+          },
+          ad_context: rawContextInfo ? sanitizeAdContext(rawContextInfo) : null,
+          quoted_text: rawContextInfo?.quotedMessage
+            ? (rawContextInfo.quotedMessage.conversation || rawContextInfo.quotedMessage.extendedTextMessage?.text || rawContextInfo.quotedMessage.imageMessage?.caption || null)
+            : null,
+        };
+
+        console.log(`[MSG] ${fromMe ? '→' : '←'} ${contactPhone} (${contactName}) | ${contentType} | ${messageText.substring(0, 100)}`);
+        send({ type: 'message', payload });
+        logDispatched(msg, { contentType, contactPhone, messageText: messageText.slice(0, 200) });
+      }
+    });
+
+    send({ type: 'ready' });
+  } catch (err) {
+    send({ type: 'reply', reqId: '__init__', error: err.message });
+    process.exit(1);
+  }
+}
+
+// ─── Media Forwarding ───────────────────────────────────
+
+async function forwardMedia(msg, contentType, toJid, senderName, senderPhone) {
+  const label = `[${senderName} ${senderPhone}]`;
+  try {
+    const mediaMsg = msg.message;
+    const DOWNLOADABLE = ['imageMessage', 'videoMessage', 'audioMessage', 'documentMessage', 'stickerMessage'];
+
+    if (DOWNLOADABLE.includes(contentType)) {
+      const buffer = await downloadMediaMessage(msg, 'buffer', {});
+      const caption = `${label} — ${contentType.replace('Message', '')}`;
+
+      if (contentType === 'imageMessage') {
+        await sock.sendMessage(toJid, { image: buffer, caption });
+      } else if (contentType === 'videoMessage') {
+        await sock.sendMessage(toJid, { video: buffer, caption });
+      } else if (contentType === 'audioMessage') {
+        const mimetype = mediaMsg.audioMessage?.mimetype || 'audio/ogg; codecs=opus';
+        await sock.sendMessage(toJid, { audio: buffer, mimetype });
+        await sock.sendMessage(toJid, { text: caption });
+      } else if (contentType === 'documentMessage') {
+        const mimetype = mediaMsg.documentMessage?.mimetype || 'application/octet-stream';
+        const fileName = mediaMsg.documentMessage?.fileName || 'document';
+        await sock.sendMessage(toJid, { document: buffer, mimetype, fileName, caption });
+      } else if (contentType === 'stickerMessage') {
+        await sock.sendMessage(toJid, { sticker: buffer });
+        await sock.sendMessage(toJid, { text: caption });
+      }
+    } else {
+      // Non-downloadable media (location, contacts, polls, etc.)
+      await sock.sendMessage(toJid, { text: `${label} — ${contentType}` });
+    }
+  } catch (err) {
+    // Fallback: send text notification if download/forward fails
+    try {
+      await sock.sendMessage(toJid, { text: `${label} — ${contentType} (download failed)` });
+    } catch {}
+  }
+}
+
+// ─── Command Handlers ────────────────────────────────────
+
+async function handleSend({ chatId, text, reqId }) {
+  try {
+    if (!sock) throw new Error('Socket not connected');
+    const result = await sock.sendMessage(chatId, { text });
+    send({ type: 'reply', reqId, data: { message_id: result?.key?.id || null } });
+  } catch (err) {
+    send({ type: 'reply', reqId, error: err.message });
+  }
+}
+
+async function handleForwardMedia({ messageId, toPhone, caption, reqId }) {
+  try {
+    if (!sock) throw new Error('Socket not connected');
+
+    const cached = messageCache.get(messageId);
+    if (!cached) throw new Error('Message not in cache (expired or not found)');
+
+    const { msg, contentType } = cached;
+    const toJid = toPhone.replace(/[^0-9]/g, '') + '@s.whatsapp.net';
+
+    const DOWNLOADABLE = ['imageMessage', 'videoMessage', 'audioMessage', 'documentMessage', 'stickerMessage'];
+
+    if (DOWNLOADABLE.includes(contentType)) {
+      const buffer = await downloadMediaMessage(msg, 'buffer', {});
+
+      if (contentType === 'imageMessage') {
+        await sock.sendMessage(toJid, { image: buffer, caption: caption || '' });
+      } else if (contentType === 'videoMessage') {
+        await sock.sendMessage(toJid, { video: buffer, caption: caption || '' });
+      } else if (contentType === 'audioMessage') {
+        const mimetype = msg.message?.audioMessage?.mimetype || 'audio/ogg; codecs=opus';
+        await sock.sendMessage(toJid, { audio: buffer, mimetype });
+        if (caption) await sock.sendMessage(toJid, { text: caption });
+      } else if (contentType === 'documentMessage') {
+        const mimetype = msg.message?.documentMessage?.mimetype || 'application/octet-stream';
+        const fileName = msg.message?.documentMessage?.fileName || 'document';
+        await sock.sendMessage(toJid, { document: buffer, mimetype, fileName, caption: caption || '' });
+      } else if (contentType === 'stickerMessage') {
+        await sock.sendMessage(toJid, { sticker: buffer });
+        if (caption) await sock.sendMessage(toJid, { text: caption });
+      }
+
+      send({ type: 'reply', reqId, data: { success: true } });
+    } else {
+      // Non-downloadable media — send caption as text
+      await sock.sendMessage(toJid, { text: caption || `[Media: ${contentType}]` });
+      send({ type: 'reply', reqId, data: { success: true } });
+    }
+  } catch (err) {
+    send({ type: 'reply', reqId, error: err.message });
+  }
+}
+
+async function handleSendImage({ chatId, imageBase64, caption, reqId }) {
+  try {
+    if (!sock) throw new Error('Socket not connected');
+    const buffer = Buffer.from(imageBase64, 'base64');
+    await sock.sendMessage(chatId, { image: buffer, caption: caption || '' });
+    send({ type: 'reply', reqId, data: { success: true } });
+  } catch (err) {
+    send({ type: 'reply', reqId, error: err.message });
+  }
+}
+
+async function handleDownloadAudio({ messageId, reqId }) {
+  try {
+    const cached = messageCache.get(messageId);
+    if (!cached) throw new Error('Message not in cache');
+    if (cached.contentType !== 'audioMessage') throw new Error('Not an audio message');
+    const buffer = await downloadMediaMessage(cached.msg, 'buffer', {});
+    const mimetype = cached.msg.message?.audioMessage?.mimetype || 'audio/ogg; codecs=opus';
+    send({ type: 'reply', reqId, data: { audio_base64: buffer.toString('base64'), mimetype } });
+  } catch (err) {
+    send({ type: 'reply', reqId, error: err.message });
+  }
+}
+
+async function handleStartChat({ phone, text, reqId }) {
+  try {
+    if (!sock) throw new Error('Socket not connected');
+    const jid = phone.replace(/[^0-9]/g, '') + '@s.whatsapp.net';
+    const result = await sock.sendMessage(jid, { text });
+    send({ type: 'reply', reqId, data: { chat_id: `${accountId}:${jid}`, message_id: result?.key?.id || null } });
+  } catch (err) {
+    send({ type: 'reply', reqId, error: err.message });
+  }
+}
+
+async function handleDisconnect() {
+  // Explicit logout — clears WhatsApp session and auth state
+  try {
+    if (sock) {
+      await sock.logout();
+    }
+  } catch {
+    // Ignore logout errors
+  }
+  if (mongoClient) {
+    try { await mongoClient.close(); } catch {}
+  }
+  process.exit(0);
+}
+
+async function handleShutdown() {
+  // Graceful close — preserves auth state for reconnection after restart
+  try {
+    if (sock) {
+      sock.end(undefined);
+    }
+  } catch {}
+  if (mongoClient) {
+    try { await mongoClient.close(); } catch {}
+  }
+  process.exit(0);
+}
+
+// ─── Handle unexpected errors ────────────────────────────
+
+process.on('uncaughtException', (err) => {
+  send({ type: 'reply', reqId: '__error__', error: `Uncaught: ${err.message}` });
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (err) => {
+  send({ type: 'reply', reqId: '__error__', error: `Unhandled: ${err?.message || err}` });
+});