@conversionpros/aiva 1.0.0

package/wa-listener.js

@@ -0,0 +1,354 @@
+// ── WhatsApp Message Listener ────────────────────────────
+// Polls wacli for new incoming WhatsApp messages and forwards them
+// to the AIVA router webhook for processing.
+//
+// Architecture: wacli sync runs as a background process maintaining
+// the WhatsApp connection. This module polls wacli's local DB for
+// new messages and POSTs them to /webhook/whatsapp.
+// Sending: sync must be stopped briefly to release the store lock,
+// then send, then restart sync.
+
+const { execSync, spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const WEBHOOK_URL = 'http://127.0.0.1:3847/webhook/whatsapp';
+const POLL_INTERVAL_MS = 5000; // 5 seconds
+const WACLI_BIN = '/opt/homebrew/bin/wacli';
+
+// Check if wacli binary exists
+let WACLI_AVAILABLE = false;
+try {
+  fs.accessSync(WACLI_BIN, fs.constants.X_OK);
+  WACLI_AVAILABLE = true;
+} catch {
+  // Also check PATH
+  try {
+    execSync('which wacli', { timeout: 3000, encoding: 'utf-8' });
+    WACLI_AVAILABLE = true;
+  } catch {
+    WACLI_AVAILABLE = false;
+  }
+}
+
+// Track processed messages to avoid duplicates
+const processedMessageIds = new Set();
+const MAX_PROCESSED_IDS = 5000;
+let lastPollTimestamp = null; // ISO timestamp of last poll
+let pollTimer = null;
+let syncProcess = null;
+let syncPid = null;
+
+// Send queue -- serialized to avoid lock contention
+let sendQueue = [];
+let sendProcessing = false;
+
+function log(msg, data) {
+  const ts = new Date().toISOString();
+  if (data) console.log(`[${ts}] [WA-LISTENER] ${msg}`, JSON.stringify(data));
+  else console.log(`[${ts}] [WA-LISTENER] ${msg}`);
+}
+
+function isAuthenticated() {
+  try {
+    const output = execSync(`${WACLI_BIN} doctor`, { timeout: 10000, encoding: 'utf-8' });
+    return output.includes('AUTHENTICATED  true');
+  } catch {
+    return false;
+  }
+}
+
+function isLocked() {
+  try {
+    const output = execSync(`${WACLI_BIN} doctor`, { timeout: 10000, encoding: 'utf-8' });
+    return output.includes('LOCKED     true');
+  } catch {
+    return false;
+  }
+}
+
+function killAllWacliSync() {
+  try {
+    execSync('pkill -f "wacli (sync|auth)"', { timeout: 5000 });
+    log('Killed existing wacli sync processes');
+  } catch {
+    // No processes to kill
+  }
+  syncProcess = null;
+  syncPid = null;
+}
+
+function startSync() {
+  // Check if already running
+  try {
+    const ps = execSync('pgrep -f "wacli (sync|auth)"', { timeout: 5000, encoding: 'utf-8' }).trim();
+    if (ps) {
+      syncPid = parseInt(ps.split('\n')[0]);
+      log('Sync already running', { pid: syncPid });
+      return true;
+    }
+  } catch {
+    // No process found
+  }
+
+  if (isLocked()) {
+    log('Store locked by another process, waiting...');
+    return false;
+  }
+
+  try {
+    syncProcess = spawn(WACLI_BIN, ['sync', '--follow', '--refresh-contacts'], {
+      detached: true,
+      stdio: 'ignore',
+    });
+    syncProcess.unref();
+    syncPid = syncProcess.pid;
+    log('Started wacli sync', { pid: syncPid });
+    return true;
+  } catch (err) {
+    log('Failed to start wacli sync', { error: err.message });
+    return false;
+  }
+}
+
+function stopSync() {
+  if (syncPid) {
+    try {
+      process.kill(syncPid, 'SIGTERM');
+      log('Stopped sync process', { pid: syncPid });
+    } catch {
+      // Process already dead
+    }
+    syncProcess = null;
+    syncPid = null;
+  }
+  // Also kill any stray wacli sync processes
+  killAllWacliSync();
+  // Wait for processes to die and lock to release
+  try { execSync('sleep 0.5'); } catch {}
+  // Force kill if anything survived
+  try { execSync('pkill -9 -f "wacli sync"', { timeout: 3000 }); } catch {}
+  try { execSync('sleep 0.3'); } catch {}
+}
+
+/**
+ * Send a WhatsApp message. Handles store lock by stopping sync,
+ * sending, then restarting sync.
+ * @param {string} phone - Phone number with + prefix
+ * @param {string} text - Message text
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+function sendMessage(phone, text) {
+  if (!WACLI_AVAILABLE) {
+    log('sendMessage called but wacli not installed -- skipping');
+    return Promise.resolve({ success: false, error: 'wacli not installed' });
+  }
+  return new Promise((resolve) => {
+    sendQueue.push({ phone, text, resolve });
+    processSendQueue();
+  });
+}
+
+async function processSendQueue() {
+  if (sendProcessing || sendQueue.length === 0) return;
+  sendProcessing = true;
+
+  // Stop sync to release the lock
+  stopSync();
+
+  // Wait for lock to fully release and WA session to free up
+  await new Promise(r => setTimeout(r, 3000));
+
+  while (sendQueue.length > 0) {
+    const { phone, text, resolve } = sendQueue.shift();
+    log('Sending WhatsApp message', { phone, textLen: text.length });
+    try {
+      const result = await new Promise((res, rej) => {
+        const child = require('child_process').exec(
+          `${WACLI_BIN} send text --to "${phone.replace(/^\+/, '')}" --message ${JSON.stringify(text)} --timeout 60s`,
+          { timeout: 90000, encoding: 'utf-8' },
+          (err, stdout, stderr) => {
+            if (err) rej(err);
+            else res(stdout);
+          }
+        );
+      });
+      log('WhatsApp send success', { phone, result: (result || '').trim().substring(0, 100) });
+      resolve({ success: true });
+    } catch (err) {
+      log('WhatsApp send FAILED', { phone, error: err.message });
+      resolve({ success: false, error: err.message });
+    }
+  }
+
+  // Restart sync
+  sendProcessing = false;
+  await new Promise(r => setTimeout(r, 300));
+  startSync();
+}
+
+function fetchNewMessages() {
+  try {
+    let cmd = `${WACLI_BIN} messages list --json --limit 20`;
+    if (lastPollTimestamp) {
+      cmd += ` --after "${lastPollTimestamp}"`;
+    } else {
+      const since = new Date(Date.now() - 60000).toISOString();
+      cmd += ` --after "${since}"`;
+    }
+
+    const output = execSync(cmd, { timeout: 15000, encoding: 'utf-8' });
+    const result = JSON.parse(output);
+
+    if (!result.success || !result.data) {
+      log('fetchNewMessages: no success/data', { success: result.success, hasData: !!result.data });
+      return [];
+    }
+    const msgs = result.data.messages;
+    if (!Array.isArray(msgs)) return [];
+    return msgs;
+  } catch (err) {
+    if (err.message && (err.message.includes('unknown flag') || err.message.includes('not found'))) {
+      return fetchNewMessagesFallback();
+    }
+    // Don't log lock errors during send operations
+    if (!sendProcessing) {
+      log('Failed to fetch messages', { error: err.message.substring(0, 150) });
+    }
+    return [];
+  }
+}
+
+function fetchNewMessagesFallback() {
+  try {
+    const cmd = `${WACLI_BIN} messages list --json --limit 20`;
+    const output = execSync(cmd, { timeout: 15000, encoding: 'utf-8' });
+    const result = JSON.parse(output);
+
+    if (!result.success || !result.data) return [];
+
+    const messages = result.data.messages;
+    if (!Array.isArray(messages)) return [];
+
+    const cutoff = lastPollTimestamp ? new Date(lastPollTimestamp).getTime() : (Date.now() - 60000);
+    return messages.filter(m => {
+      const msgTime = new Date(m.Timestamp || m.timestamp || 0).getTime();
+      return !m.FromMe && !m.fromMe && msgTime > cutoff;
+    });
+  } catch (err) {
+    if (!sendProcessing) {
+      log('Fallback fetch failed', { error: err.message.substring(0, 150) });
+    }
+    return [];
+  }
+}
+
+async function forwardToRouter(phone, text, messageId) {
+  const dedupKey = messageId || `${phone}:${text.substring(0, 100)}`;
+  if (processedMessageIds.has(dedupKey)) return;
+
+  processedMessageIds.add(dedupKey);
+
+  // Prune old entries
+  if (processedMessageIds.size > MAX_PROCESSED_IDS) {
+    const arr = [...processedMessageIds];
+    arr.splice(0, arr.length - MAX_PROCESSED_IDS / 2);
+    processedMessageIds.clear();
+    arr.forEach(id => processedMessageIds.add(id));
+  }
+
+  log('Forwarding WA message to router', { phone, textLen: text.length, messageId });
+
+  try {
+    const resp = await fetch(WEBHOOK_URL, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        from: phone,
+        text: text,
+        fromMe: false,
+        messageId: messageId,
+        _source: 'whatsapp'
+      }),
+      signal: AbortSignal.timeout(30000),
+    });
+
+    const result = await resp.json();
+    log('Router response', { phone, status: result.status, action: result.action });
+  } catch (err) {
+    log('Failed to forward to router', { phone, error: err.message });
+  }
+}
+
+function normalizePhone(jid) {
+  if (!jid) return null;
+  let phone = jid.split('@')[0];
+  phone = phone.split(':')[0];
+  if (!phone || phone.length < 7) return null;
+  return phone.startsWith('+') ? phone : '+' + phone;
+}
+
+async function pollMessages() {
+  // Don't poll while sending (sync is stopped for send)
+  if (sendProcessing) return;
+
+  // Ensure sync is running (receives messages from WA servers)
+  startSync();
+
+  const messages = fetchNewMessages();
+  if (!messages || !Array.isArray(messages)) return;
+
+  for (const msg of messages) {
+    if (msg.FromMe || msg.fromMe) continue;
+
+    const chatJid = msg.ChatJID || msg.chatJID || msg.chat || '';
+    if (chatJid.includes('@g.us')) continue;
+
+    const phone = normalizePhone(msg.SenderJID || msg.senderJID || msg.sender || chatJid);
+    const text = msg.Text || msg.DisplayText || msg.Snippet || msg.text || msg.Body || msg.body || '';
+    const messageId = msg.MsgID || msg.ID || msg.id || msg.MessageID || msg.messageId || '';
+
+    if (!phone || !text) continue;
+
+    await forwardToRouter(phone, text, messageId);
+  }
+
+  lastPollTimestamp = new Date().toISOString();
+}
+
+function start() {
+  if (!WACLI_AVAILABLE) {
+    log('wacli not installed -- WhatsApp listener disabled');
+    return;
+  }
+
+  log('Starting WhatsApp listener (wacli polling)');
+
+  if (!isAuthenticated()) {
+    log('wacli not authenticated -- WhatsApp listener inactive. Run `wacli auth` to connect.');
+  } else {
+    log('wacli authenticated, ensuring sync is running');
+    startSync();
+  }
+
+  // Look back 10 minutes on startup to catch messages that arrived during downtime
+  lastPollTimestamp = new Date(Date.now() - 600000).toISOString();
+
+  pollTimer = setInterval(async () => {
+    try {
+      await pollMessages();
+    } catch (err) {
+      log('Poll error', { error: err.message });
+    }
+  }, POLL_INTERVAL_MS);
+}
+
+function stop() {
+  if (pollTimer) {
+    clearInterval(pollTimer);
+    pollTimer = null;
+  }
+  log('WhatsApp listener stopped');
+}
+
+module.exports = { start, stop, sendMessage };