@conversionpros/aiva 1.0.0

package/router-v2/index.js

@@ -0,0 +1,441 @@
+// ── Router v2 Entry Point - Express Routes + Initialization ──
+'use strict';
+
+const { initDatabase, getSetting, setSetting, getStmts } = require('./db');
+const { ingestMessage, startBBPolling, stopBBPolling } = require('./ingestion');
+const { processMessage } = require('./conversation-engine');
+const { handleReply, processTimeouts } = require('./escalation-bridge');
+const { processFollowUps } = require('./follow-up-engine');
+const { listContacts, getContact, updateContact, deleteContact, setScopes, getOrCreateContact } = require('./contact-manager');
+const { listFaq, createFaq, updateFaq, deleteFaq, search: searchKB } = require('./knowledge-base');
+const { listSections, createSection, updateSection, deleteSection } = require('./playbook');
+const { listPreferences, deletePreference, getMetrics, decayConfidence } = require('./learning-loop');
+const { normalizePhone } = require('./utils/phone');
+
+let initialized = false;
+let timeoutTimer = null;
+let followUpTimer = null;
+let decayTimer = null;
+
+function log(msg, data) {
+  const ts = new Date().toISOString();
+  if (data) console.log(`[${ts}] [ROUTER-V2] ${msg}`, JSON.stringify(data));
+  else console.log(`[${ts}] [ROUTER-V2] ${msg}`);
+}
+
+/**
+ * Initialize the router v2. Call once at startup.
+ * @returns {Object} { db, stmts }
+ */
+function initialize() {
+  if (initialized) return;
+
+  const result = initDatabase();
+  log('Database initialized');
+
+  // Start BB polling for Brandon's manual messages
+  startBBPolling(30000);
+
+  // Start escalation timeout checker (every 60s)
+  timeoutTimer = setInterval(() => {
+    processTimeouts().catch(err => log('Timeout check error', { error: err.message }));
+  }, 60000);
+
+  // Start follow-up engine (every 30 min)
+  followUpTimer = setInterval(() => {
+    processFollowUps().catch(err => log('Follow-up error', { error: err.message }));
+  }, 30 * 60000);
+
+  // Confidence decay (daily)
+  decayTimer = setInterval(() => {
+    decayConfidence();
+  }, 24 * 3600000);
+
+  initialized = true;
+  log('Router v2 initialized');
+  return result;
+}
+
+/**
+ * Shutdown cleanup.
+ */
+function shutdown() {
+  stopBBPolling();
+  if (timeoutTimer) clearInterval(timeoutTimer);
+  if (followUpTimer) clearInterval(followUpTimer);
+  if (decayTimer) clearInterval(decayTimer);
+  log('Router v2 shut down');
+}
+
+/**
+ * Register Express routes on an existing app.
+ * @param {import('express').Application} app - Express app
+ */
+function registerRoutes(app) {
+  // ── Webhook endpoints (inbound messages) ──
+
+  // iMessage / BlueBubbles webhook
+  app.post('/webhook/imessage', (req, res) => {
+    try {
+      ingestMessage(req.body, 'imessage', (message) => {
+        processMessage(message).catch(err => log('Process error', { phone: message.phone, error: err.message }));
+      });
+      res.json({ ok: true });
+    } catch (err) {
+      log('iMessage webhook error', { error: err.message });
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // WhatsApp webhook
+  app.post('/webhook/whatsapp', (req, res) => {
+    try {
+      ingestMessage(req.body, 'whatsapp', (message) => {
+        processMessage(message).catch(err => log('Process error', { phone: message.phone, error: err.message }));
+      });
+      res.json({ ok: true });
+    } catch (err) {
+      log('WhatsApp webhook error', { error: err.message });
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // Quo / OpenPhone webhook
+  app.post('/webhook/quo', (req, res) => {
+    try {
+      ingestMessage(req.body, 'quo', (message) => {
+        processMessage(message).catch(err => log('Process error', { phone: message.phone, error: err.message }));
+      });
+      res.json({ ok: true });
+    } catch (err) {
+      log('Quo webhook error', { error: err.message });
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // ── Escalation reply endpoint ──
+  app.post('/api/router/escalation-reply', async (req, res) => {
+    try {
+      const result = await handleReply(req.body);
+      res.json(result);
+    } catch (err) {
+      log('Escalation reply error', { error: err.message });
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // ── Escalation action handler (from interactive UI) ──
+  app.post('/api/router/escalation-action', async (req, res) => {
+    try {
+      const { escalationId, actionIndex, actionType, scopes, phone } = req.body;
+      log('Escalation action received', { escalationId, actionType, scopes, phone });
+
+      // Grant scopes if action requires it
+      if (actionType === 'approve_and_grant' && scopes && scopes.length > 0 && phone) {
+        const scopeMap = {};
+        scopes.forEach(s => { scopeMap[s] = true; });
+        setScopes(normalizePhone(phone), scopeMap);
+        log('Scopes granted via escalation action', { phone, scopes });
+      }
+
+      // Handle the reply based on action type
+      if (actionType === 'approve_and_grant' || actionType === 'approve_one_time') {
+        // Reply affirmatively to the contact
+        const result = await handleReply({ escalationId, response: 'Yes, approve and confirm their request' });
+        res.json({ success: true, action: actionType, scopesGranted: scopes || [], reply: result });
+      } else if (actionType === 'decline') {
+        const result = await handleReply({ escalationId, response: 'Politely decline their request' });
+        res.json({ success: true, action: actionType, reply: result });
+      } else if (actionType === 'ignore' || actionType === 'handle_personally') {
+        // No reply to contact
+        res.json({ success: true, action: actionType, noReply: true });
+      } else {
+        res.json({ success: true, action: 'unknown', note: 'No automated action taken' });
+      }
+    } catch (err) {
+      log('Escalation action error', { error: err.message });
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // ── Contact management API ──
+
+  app.get('/api/v2/contacts', (req, res) => {
+    try {
+      const filter = {};
+      if (req.query.category) filter.category = req.query.category;
+      if (req.query.search) filter.search = req.query.search;
+      res.json(listContacts(filter));
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.get('/api/v2/contacts/:phone', (req, res) => {
+    try {
+      const contact = getContact(normalizePhone(req.params.phone));
+      if (!contact) return res.status(404).json({ error: 'Contact not found' });
+      res.json(contact);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.put('/api/v2/contacts/:phone', (req, res) => {
+    try {
+      const phone = normalizePhone(req.params.phone);
+      // Ensure contact exists
+      getOrCreateContact(phone, req.body);
+      const updated = updateContact(phone, req.body);
+      if (!updated) return res.status(404).json({ error: 'Contact not found' });
+      res.json(updated);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.delete('/api/v2/contacts/:phone', (req, res) => {
+    try {
+      deleteContact(normalizePhone(req.params.phone));
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // Scopes management
+  app.put('/api/v2/contacts/:phone/scopes', (req, res) => {
+    try {
+      setScopes(normalizePhone(req.params.phone), req.body.scopes || {});
+      const contact = getContact(normalizePhone(req.params.phone));
+      res.json({ scopes: contact?.scopes || [] });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // ── FAQ management API ──
+
+  app.get('/api/v2/faq', (req, res) => {
+    try {
+      res.json(listFaq(req.query.deviceId || null));
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.post('/api/v2/faq', (req, res) => {
+    try {
+      const entry = createFaq(req.body);
+      res.json(entry);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.put('/api/v2/faq/:id', (req, res) => {
+    try {
+      const entry = updateFaq(parseInt(req.params.id), req.body);
+      if (!entry) return res.status(404).json({ error: 'FAQ entry not found' });
+      res.json(entry);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.delete('/api/v2/faq/:id', (req, res) => {
+    try {
+      deleteFaq(parseInt(req.params.id));
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.get('/api/v2/faq/search', (req, res) => {
+    try {
+      const results = searchKB(req.query.q || '', req.query.deviceId || null);
+      res.json(results);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // ── Playbook management API ──
+
+  app.get('/api/v2/playbook', (req, res) => {
+    try {
+      res.json(listSections(req.query.deviceId || null));
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.post('/api/v2/playbook', (req, res) => {
+    try {
+      const section = createSection(req.body);
+      res.json(section);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.put('/api/v2/playbook/:id', (req, res) => {
+    try {
+      const section = updateSection(parseInt(req.params.id), req.body);
+      if (!section) return res.status(404).json({ error: 'Section not found' });
+      res.json(section);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.delete('/api/v2/playbook/:id', (req, res) => {
+    try {
+      deleteSection(parseInt(req.params.id));
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // ── Preferences / Learning API ──
+
+  app.get('/api/v2/preferences', (req, res) => {
+    try {
+      res.json(listPreferences());
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.delete('/api/v2/preferences/:id', (req, res) => {
+    try {
+      deletePreference(parseInt(req.params.id));
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.get('/api/v2/learning/metrics', (req, res) => {
+    try {
+      res.json(getMetrics());
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // ── Settings API ──
+
+  app.get('/api/v2/settings', (req, res) => {
+    try {
+      const stmts = getStmts();
+      const all = stmts.getAllSettings.all();
+      const settings = Object.fromEntries(all.map(s => [s.key, s.value]));
+      res.json(settings);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.put('/api/v2/settings', (req, res) => {
+    try {
+      for (const [key, value] of Object.entries(req.body)) {
+        setSetting(key, value);
+      }
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // ── Follow-up management ──
+
+  app.get('/api/v2/follow-ups', (req, res) => {
+    try {
+      res.json(getStmts().getAllFollowUps.all());
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.post('/api/v2/follow-ups/:phone/send', async (req, res) => {
+    try {
+      const { sendFollowUpNow } = require('./follow-up-engine');
+      const result = await sendFollowUpNow(normalizePhone(req.params.phone), req.body.message);
+      res.json(result);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.delete('/api/v2/follow-ups/:phone', (req, res) => {
+    try {
+      getStmts().deleteFollowUp.run(normalizePhone(req.params.phone));
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // ── Message log ──
+
+  app.get('/api/v2/messages', (req, res) => {
+    try {
+      const phone = req.query.phone ? normalizePhone(req.query.phone) : null;
+      const limit = parseInt(req.query.limit) || 50;
+      const stmts = getStmts();
+      const messages = phone
+        ? stmts.getRecentMessages.all(phone, limit)
+        : stmts.getRecentMessagesAll.all(limit);
+      res.json(messages);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // ── Send message (manual / API) ──
+
+  app.post('/api/v2/send', async (req, res) => {
+    try {
+      const { sendMessage } = require('./outbound-sender');
+      const result = await sendMessage({
+        phone: normalizePhone(req.body.phone),
+        text: req.body.message || req.body.text,
+        channel: req.body.channel || 'imessage',
+        sentBy: req.body.sentBy || 'aiva',
+        stateAtTime: req.body.stateAtTime || 'manual',
+      });
+      res.json(result);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // ── Escalation management ──
+
+  app.get('/api/v2/escalations', (req, res) => {
+    try {
+      const db = require('./db').getDb();
+      const escalations = db.prepare("SELECT * FROM escalations ORDER BY created_at DESC LIMIT ?").all(parseInt(req.query.limit) || 50);
+      res.json(escalations);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // ── Health check ──
+
+  app.get('/api/v2/health', (req, res) => {
+    res.json({
+      version: 'v2',
+      initialized,
+      timestamp: new Date().toISOString(),
+    });
+  });
+
+  log('Routes registered');
+}
+
+module.exports = { initialize, shutdown, registerRoutes };

package/router-v2/ingestion.js

@@ -0,0 +1,213 @@
+// ── Message Ingestion - Normalize + Debounce + BB Polling ──
+'use strict';
+
+const { getStmts, getSetting } = require('./db');
+const { normalizePhone } = require('./utils/phone');
+const imessageAdapter = require('./adapters/imessage');
+
+// Debounce state: phone -> { timer, messages: [] }
+const debounceMap = new Map();
+// Per-phone processing lock to prevent concurrent AI calls
+const processingLocks = new Set();
+// Processed message IDs for dedup
+const processedIds = new Set();
+const MAX_PROCESSED = 5000;
+// Last BB poll timestamp (epoch ms)
+let lastBBPollMs = Date.now() - 60000;
+let bbPollTimer = null;
+
+function log(msg, data) {
+  const ts = new Date().toISOString();
+  if (data) console.log(`[${ts}] [INGESTION] ${msg}`, JSON.stringify(data));
+  else console.log(`[${ts}] [INGESTION] ${msg}`);
+}
+
+/**
+ * Normalize a raw webhook payload from any channel into the unified InboundMessage format.
+ * @param {Object} rawPayload - Raw webhook data
+ * @param {string} channel - 'imessage' | 'whatsapp' | 'quo'
+ * @returns {Object|null} Normalized message or null if irrelevant
+ */
+function normalizeMessage(rawPayload, channel) {
+  let adapter;
+  switch (channel) {
+    case 'imessage':
+      adapter = require('./adapters/imessage');
+      break;
+    case 'whatsapp':
+      adapter = require('./adapters/whatsapp');
+      break;
+    case 'quo':
+      adapter = require('./adapters/quo');
+      break;
+    default:
+      log('Unknown channel', { channel });
+      return null;
+  }
+
+  const parsed = adapter.parseWebhook(rawPayload);
+  if (!parsed) return null;
+
+  // Normalize phone
+  parsed.phone = normalizePhone(parsed.phone);
+  if (!parsed.phone) return null;
+
+  return parsed;
+}
+
+/**
+ * Check if a message is a duplicate (already processed).
+ * @param {string} messageId
+ * @returns {boolean}
+ */
+function isDuplicate(messageId) {
+  if (!messageId) return false;
+  if (processedIds.has(messageId)) return true;
+
+  processedIds.add(messageId);
+  // Prune old IDs
+  if (processedIds.size > MAX_PROCESSED) {
+    const idsArray = Array.from(processedIds);
+    for (let i = 0; i < idsArray.length - MAX_PROCESSED / 2; i++) {
+      processedIds.delete(idsArray[i]);
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Debounce rapid-fire messages from the same contact.
+ * Calls the callback with all accumulated messages after the debounce window.
+ * @param {Object} message - Normalized inbound message
+ * @param {Function} onReady - Callback(messages[]) when debounce window closes
+ */
+function debounceMessage(message, onReady) {
+  const debounceMs = parseInt(getSetting('debounceMs')) || 3000;
+  const phone = message.phone;
+
+  if (debounceMap.has(phone)) {
+    const entry = debounceMap.get(phone);
+    clearTimeout(entry.timer);
+    entry.messages.push(message);
+    entry.timer = setTimeout(() => {
+      debounceMap.delete(phone);
+      onReady(entry.messages);
+    }, debounceMs);
+  } else {
+    const entry = {
+      messages: [message],
+      timer: setTimeout(() => {
+        debounceMap.delete(phone);
+        onReady(entry.messages);
+      }, debounceMs),
+    };
+    debounceMap.set(phone, entry);
+  }
+}
+
+/**
+ * Process a raw inbound webhook: normalize, dedup, debounce, then invoke callback.
+ * @param {Object} rawPayload - Raw webhook data
+ * @param {string} channel - Channel identifier
+ * @param {Function} onMessage - Callback(normalizedMessage) for processing
+ */
+function ingestMessage(rawPayload, channel, onMessage) {
+  const message = normalizeMessage(rawPayload, channel);
+  if (!message) return;
+
+  // TEMPORARILY DISABLED for testing (2026-02-27)
+  // Skip master phone messages (Brandon's own messages come through polling)
+  // const masterPhone = getSetting('masterPhone');
+  // if (message.phone === masterPhone) return;
+
+  // Dedup
+  if (isDuplicate(message.id)) {
+    log('Duplicate skipped', { id: message.id, phone: message.phone });
+    return;
+  }
+
+  // Log inbound message
+  const stmts = getStmts();
+  stmts.insertMessage.run(
+    message.phone, message.channel, 'inbound', message.text,
+    JSON.stringify(message.attachments || []), 'contact', '',
+  );
+
+  // Debounce then process (with per-phone lock to prevent concurrent AI calls)
+  debounceMessage(message, async (messages) => {
+    const phone = messages[0].phone;
+    const msg = messages.length === 1
+      ? messages[0]
+      : { ...messages[messages.length - 1], text: messages.map(m => m.text).filter(Boolean).join('\n') };
+
+    // Wait for any in-flight processing for this phone to finish
+    while (processingLocks.has(phone)) {
+      await new Promise(r => setTimeout(r, 200));
+    }
+
+    processingLocks.add(phone);
+    try {
+      await onMessage(msg);
+    } catch (err) {
+      log('Processing error', { phone, error: err.message });
+    } finally {
+      processingLocks.delete(phone);
+    }
+  });
+}
+
+/**
+ * Start polling BlueBubbles for Brandon's manual messages.
+ * These are messages Brandon sends directly via iMessage (not through AIVA).
+ * @param {number} [intervalMs=30000] - Poll interval
+ */
+function startBBPolling(intervalMs = 30000) {
+  if (bbPollTimer) return;
+
+  async function poll() {
+    try {
+      const messages = await imessageAdapter.pollBrandonMessages(lastBBPollMs);
+      if (messages.length > 0) {
+        const stmts = getStmts();
+        for (const msg of messages) {
+          if (!msg.phone || isDuplicate(msg.guid)) continue;
+
+          const phone = normalizePhone(msg.phone);
+          // Log as outbound with sent_by: 'brandon'
+          stmts.insertMessage.run(
+            phone, 'imessage', 'outbound', msg.text,
+            '[]', 'brandon', '',
+          );
+          log('Tracked Brandon message', { phone, len: msg.text.length });
+        }
+        lastBBPollMs = Math.max(...messages.map(m => m.timestamp), lastBBPollMs);
+      }
+    } catch (err) {
+      log('BB poll error', { error: err.message });
+    }
+  }
+
+  bbPollTimer = setInterval(poll, intervalMs);
+  poll(); // Initial poll
+  log('Started BB polling', { intervalMs });
+}
+
+/**
+ * Stop BB polling.
+ */
+function stopBBPolling() {
+  if (bbPollTimer) {
+    clearInterval(bbPollTimer);
+    bbPollTimer = null;
+  }
+}
+
+module.exports = {
+  normalizeMessage,
+  isDuplicate,
+  debounceMessage,
+  ingestMessage,
+  startBBPolling,
+  stopBBPolling,
+};