@conversionpros/aiva 1.0.0

package/router-v2/adapters/imessage.js

@@ -0,0 +1,191 @@
+// ── iMessage Adapter (BlueBubbles REST API) ──────────────
+// No CLI dependency - uses BlueBubbles REST API directly.
+'use strict';
+
+const { getSetting } = require('../db');
+
+// BlueBubbles config - read from settings or env
+function getBBConfig() {
+  return {
+    url: process.env.BLUEBUBBLES_URL || getSetting('blueBubblesUrl') || 'http://localhost:1234',
+    password: process.env.BLUEBUBBLES_PASSWORD || getSetting('blueBubblesPassword') || '',
+  };
+}
+
+function log(msg, data) {
+  const ts = new Date().toISOString();
+  if (data) console.log(`[${ts}] [IMESSAGE] ${msg}`, JSON.stringify(data));
+  else console.log(`[${ts}] [IMESSAGE] ${msg}`);
+}
+
+/**
+ * Send an iMessage via BlueBubbles REST API.
+ * @param {string} phone - E.164 phone number
+ * @param {string} text - Message text
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+async function send(phone, text) {
+  const config = getBBConfig();
+  if (!config.password) {
+    log('No BlueBubbles password configured');
+    return { success: false, error: 'no_bb_password' };
+  }
+
+  try {
+    const resp = await fetch(`${config.url}/api/v1/message/text?password=${encodeURIComponent(config.password)}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        chatGuid: `iMessage;-;${phone}`,
+        tempGuid: `temp-${Date.now()}`,
+        message: text,
+        method: 'private-api',
+      }),
+      signal: AbortSignal.timeout(30000),
+    });
+
+    if (!resp.ok) {
+      const errText = await resp.text().catch(() => 'unknown');
+      log('BB API error', { status: resp.status, body: errText.substring(0, 200) });
+      return { success: false, error: `bb_http_${resp.status}` };
+    }
+
+    const data = await resp.json();
+    if (data.status === 200 || data.status === 201) {
+      return { success: true };
+    }
+
+    log('BB API unexpected status', { data });
+    return { success: false, error: `bb_status_${data.status}` };
+  } catch (err) {
+    log('BB API request failed', { error: err.message });
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Fetch recent messages from BlueBubbles for a specific chat.
+ * Used for manual message polling (tracking Brandon's direct texts).
+ * @param {string} phone - E.164 phone number
+ * @param {number} [limit=20]
+ * @param {number} [afterMs] - Only messages after this timestamp (epoch ms)
+ * @returns {Promise<Array>}
+ */
+async function fetchRecentMessages(phone, limit = 20, afterMs = null) {
+  const config = getBBConfig();
+  if (!config.password) return [];
+
+  try {
+    const chatGuid = `iMessage;-;${phone}`;
+    let url = `${config.url}/api/v1/chat/${encodeURIComponent(chatGuid)}/message?password=${encodeURIComponent(config.password)}&limit=${limit}&sort=desc`;
+    if (afterMs) url += `&after=${afterMs}`;
+
+    const resp = await fetch(url, {
+      signal: AbortSignal.timeout(15000),
+    });
+    if (!resp.ok) return [];
+
+    const data = await resp.json();
+    return (data.data || []).map(msg => ({
+      id: msg.guid,
+      text: msg.text || '',
+      isFromMe: msg.isFromMe,
+      dateCreated: msg.dateCreated,
+      attachments: (msg.attachments || []).map(a => ({
+        type: a.mimeType,
+        filename: a.transferName,
+        url: `${config.url}/api/v1/attachment/${a.guid}/download`,
+        password: config.password,
+      })),
+    }));
+  } catch (err) {
+    log('Fetch messages failed', { phone, error: err.message });
+    return [];
+  }
+}
+
+/**
+ * Poll BlueBubbles for messages Brandon sent directly (manual messages).
+ * Returns messages sent by Brandon (isFromMe=true) since the given timestamp.
+ * @param {number} sinceMs - Epoch milliseconds
+ * @returns {Promise<Array<{phone: string, text: string, timestamp: number}>>}
+ */
+async function pollBrandonMessages(sinceMs) {
+  const config = getBBConfig();
+  if (!config.password) return [];
+
+  try {
+    const url = `${config.url}/api/v1/message?password=${encodeURIComponent(config.password)}&after=${sinceMs}&sort=desc&limit=50`;
+    const resp = await fetch(url, {
+      signal: AbortSignal.timeout(15000),
+    });
+    if (!resp.ok) return [];
+
+    const data = await resp.json();
+    const messages = (data.data || [])
+      .filter(msg => msg.isFromMe && !msg.isArchived && msg.text)
+      .map(msg => {
+        // Extract phone from chat participants
+        const chat = msg.chats?.[0];
+        const chatGuid = chat?.guid || '';
+        const phoneMatch = chatGuid.match(/;([+-]?\d+)$/);
+        const phone = phoneMatch ? (phoneMatch[1].startsWith('+') ? phoneMatch[1] : `+${phoneMatch[1]}`) : '';
+
+        return {
+          phone,
+          text: msg.text,
+          timestamp: msg.dateCreated,
+          guid: msg.guid,
+        };
+      })
+      .filter(msg => msg.phone);
+
+    return messages;
+  } catch (err) {
+    log('Poll Brandon messages failed', { error: err.message });
+    return [];
+  }
+}
+
+/**
+ * Parse an incoming BlueBubbles webhook payload into normalized format.
+ * @param {Object} payload - Raw webhook payload
+ * @returns {Object|null} Normalized message or null if not a relevant message
+ */
+function parseWebhook(payload) {
+  const msg = payload?.data || payload;
+  if (!msg) return null;
+
+  // Skip non-text messages, reactions, and group chats
+  if (msg.associatedMessageType || msg.isArchived) return null;
+  if (msg.isFromMe) return null; // We track Brandon's messages via polling
+
+  const chatGuid = msg.chats?.[0]?.guid || '';
+  // Skip group chats (v2.1)
+  if (chatGuid.includes(';+;')) return null;
+
+  const phoneMatch = chatGuid.match(/;([+-]?\d+)$/);
+  if (!phoneMatch) return null;
+
+  let phone = phoneMatch[1];
+  if (!phone.startsWith('+')) phone = `+${phone}`;
+
+  // Check for tapback/reaction
+  const tapbackPattern = /^(Loved|Liked|Disliked|Laughed at|Emphasized|Questioned) ".+"/;
+  if (tapbackPattern.test(msg.text?.trim())) return null;
+
+  return {
+    id: msg.guid,
+    phone,
+    channel: 'imessage',
+    text: msg.text || '',
+    attachments: (msg.attachments || []).map(a => ({
+      type: a.mimeType,
+      filename: a.transferName,
+    })),
+    timestamp: new Date(msg.dateCreated),
+    raw: payload,
+  };
+}
+
+module.exports = { send, fetchRecentMessages, pollBrandonMessages, parseWebhook };

package/router-v2/adapters/quo.js

@@ -0,0 +1,82 @@
+// ── Quo / OpenPhone Adapter ──────────────────────────────
+// Handles OpenPhone webhook ingestion and outbound via API.
+'use strict';
+
+const { getSetting } = require('../db');
+
+function log(msg, data) {
+  const ts = new Date().toISOString();
+  if (data) console.log(`[${ts}] [QUO] ${msg}`, JSON.stringify(data));
+  else console.log(`[${ts}] [QUO] ${msg}`);
+}
+
+/**
+ * Send a message via OpenPhone/Quo API.
+ * @param {string} phone - E.164 phone number
+ * @param {string} text - Message text
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+async function send(phone, text) {
+  const apiKey = process.env.OPENPHONE_API_KEY || getSetting('openphoneApiKey');
+  const fromNumber = process.env.OPENPHONE_NUMBER || getSetting('openphoneNumber');
+
+  if (!apiKey) {
+    log('No OpenPhone API key configured');
+    return { success: false, error: 'no_api_key' };
+  }
+
+  try {
+    const resp = await fetch('https://api.openphone.com/v1/messages', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': apiKey,
+      },
+      body: JSON.stringify({
+        from: fromNumber,
+        to: [phone],
+        content: text,
+      }),
+      signal: AbortSignal.timeout(30000),
+    });
+
+    if (!resp.ok) {
+      const errText = await resp.text().catch(() => 'unknown');
+      log('API error', { status: resp.status, body: errText.substring(0, 200) });
+      return { success: false, error: `openphone_http_${resp.status}` };
+    }
+
+    return { success: true };
+  } catch (err) {
+    log('API request failed', { error: err.message });
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Parse an OpenPhone/Quo webhook payload into normalized format.
+ * @param {Object} payload - Raw webhook payload
+ * @returns {Object|null}
+ */
+function parseWebhook(payload) {
+  if (!payload) return null;
+
+  const data = payload.data || payload;
+  const phone = data.from || '';
+  if (!phone) return null;
+
+  return {
+    id: data.id || `quo-${Date.now()}`,
+    phone: phone.startsWith('+') ? phone : `+${phone}`,
+    channel: 'quo',
+    text: data.body || data.content || data.text || '',
+    attachments: (data.media || []).map(m => ({
+      type: m.type || 'unknown',
+      url: m.url,
+    })),
+    timestamp: data.createdAt ? new Date(data.createdAt) : new Date(),
+    raw: payload,
+  };
+}
+
+module.exports = { send, parseWebhook };

package/router-v2/adapters/whatsapp.js

@@ -0,0 +1,192 @@
+// ── WhatsApp Adapter (wacli CLI) ─────────────────────────
+// Improved send queue - no longer stops the world.
+// Uses a serialized queue that briefly pauses sync for sends.
+'use strict';
+
+const { execSync, spawn, exec } = require('child_process');
+const fs = require('fs');
+
+const WACLI_BIN = '/opt/homebrew/bin/wacli';
+let WACLI_AVAILABLE = false;
+
+try {
+  fs.accessSync(WACLI_BIN, fs.constants.X_OK);
+  WACLI_AVAILABLE = true;
+} catch {
+  try {
+    execSync('which wacli', { timeout: 3000, encoding: 'utf-8' });
+    WACLI_AVAILABLE = true;
+  } catch {
+    WACLI_AVAILABLE = false;
+  }
+}
+
+let syncProcess = null;
+let syncPid = null;
+let sendQueue = [];
+let sendProcessing = false;
+
+function log(msg, data) {
+  const ts = new Date().toISOString();
+  if (data) console.log(`[${ts}] [WHATSAPP] ${msg}`, JSON.stringify(data));
+  else console.log(`[${ts}] [WHATSAPP] ${msg}`);
+}
+
+function killAllSync() {
+  try { execSync('pkill -f "wacli (sync|auth)"', { timeout: 5000 }); } catch { /* none running */ }
+  syncProcess = null;
+  syncPid = null;
+}
+
+/**
+ * Start wacli sync process if not already running.
+ * @returns {boolean}
+ */
+function startSync() {
+  if (!WACLI_AVAILABLE) return false;
+
+  try {
+    const ps = execSync('pgrep -f "wacli (sync|auth)"', { timeout: 5000, encoding: 'utf-8' }).trim();
+    if (ps) {
+      syncPid = parseInt(ps.split('\n')[0]);
+      return true;
+    }
+  } catch { /* no process */ }
+
+  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 sync', { error: err.message });
+    return false;
+  }
+}
+
+function stopSync() {
+  if (syncPid) {
+    try { process.kill(syncPid, 'SIGTERM'); } catch { /* dead */ }
+    syncProcess = null;
+    syncPid = null;
+  }
+  killAllSync();
+}
+
+/**
+ * Send a WhatsApp message. Queued to avoid lock contention.
+ * @param {string} phone - E.164 phone number
+ * @param {string} text - Message text
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+async function send(phone, text) {
+  if (!WACLI_AVAILABLE) {
+    return { 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;
+
+  // Briefly stop sync to release lock
+  stopSync();
+  await new Promise(r => setTimeout(r, 2000));
+
+  while (sendQueue.length > 0) {
+    const { phone, text, resolve } = sendQueue.shift();
+    log('Sending', { phone, textLen: text.length });
+
+    try {
+      const result = await new Promise((res, rej) => {
+        exec(
+          `${WACLI_BIN} send text --to "${phone.replace(/^\+/, '')}" --message ${JSON.stringify(text)} --timeout 60s`,
+          { timeout: 90000, encoding: 'utf-8' },
+          (err, stdout) => {
+            if (err) rej(err);
+            else res(stdout);
+          }
+        );
+      });
+      log('Send success', { phone });
+      resolve({ success: true });
+    } catch (err) {
+      log('Send FAILED', { phone, error: err.message });
+      resolve({ success: false, error: err.message });
+    }
+
+    // Small pause between sends
+    if (sendQueue.length > 0) await new Promise(r => setTimeout(r, 500));
+  }
+
+  sendProcessing = false;
+  // Restart sync
+  await new Promise(r => setTimeout(r, 300));
+  startSync();
+}
+
+/**
+ * Fetch recent messages from wacli.
+ * @param {string} [afterTimestamp] - ISO timestamp
+ * @param {number} [limit=20]
+ * @returns {Array}
+ */
+function fetchMessages(afterTimestamp = null, limit = 20) {
+  if (!WACLI_AVAILABLE) return [];
+
+  try {
+    let cmd = `${WACLI_BIN} messages list --json --limit ${limit}`;
+    if (afterTimestamp) cmd += ` --after "${afterTimestamp}"`;
+
+    const output = execSync(cmd, { timeout: 15000, encoding: 'utf-8' });
+    const messages = JSON.parse(output);
+    return Array.isArray(messages) ? messages : [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Parse a WhatsApp webhook payload into normalized format.
+ * @param {Object} payload - Raw webhook payload
+ * @returns {Object|null}
+ */
+function parseWebhook(payload) {
+  if (!payload) return null;
+
+  // Handle wacli webhook format
+  const msg = payload.message || payload;
+  const phone = msg.from || msg.phone || '';
+  if (!phone) return null;
+
+  const normalized = phone.startsWith('+') ? phone : `+${phone.replace(/^\\+/, '')}`;
+
+  return {
+    id: msg.id || `wa-${Date.now()}`,
+    phone: normalized,
+    channel: 'whatsapp',
+    text: msg.text || msg.body || '',
+    attachments: [],
+    timestamp: msg.timestamp ? new Date(msg.timestamp) : new Date(),
+    raw: payload,
+  };
+}
+
+/**
+ * Check if wacli is available and authenticated.
+ * @returns {boolean}
+ */
+function isAvailable() {
+  return WACLI_AVAILABLE;
+}
+
+module.exports = { send, fetchMessages, parseWebhook, startSync, stopSync, isAvailable };

package/router-v2/contact-manager.js

@@ -0,0 +1,234 @@
+// ── Contact Manager - CRUD + Context + Qualification ─────
+'use strict';
+
+const { getStmts, getSetting } = require('./db');
+const { normalizePhone } = require('./utils/phone');
+
+// Default scopes per category (from design doc Section 7.3)
+const DEFAULT_SCOPES = {
+  family: ['calendar.view', 'calendar.book', 'calendar.modify', 'messages.send', 'messages.auto-reply', 'info.business', 'info.personal', 'reminders.create'],
+  friend: ['calendar.view', 'calendar.book', 'messages.auto-reply', 'info.business'],
+  client: ['calendar.view', 'calendar.book', 'messages.auto-reply', 'info.business', 'support.technical'],
+  'qualified-lead': ['calendar.view', 'calendar.book', 'messages.auto-reply', 'info.business'],
+  lead: ['messages.auto-reply', 'info.business'],
+  team: ['calendar.view', 'calendar.book', 'calendar.modify', 'messages.send', 'messages.auto-reply', 'tasks.create', 'info.business', 'reminders.create'],
+  unknown: ['messages.auto-reply'],
+  blocked: [],
+};
+
+function log(msg, data) {
+  const ts = new Date().toISOString();
+  if (data) console.log(`[${ts}] [CONTACT-MGR] ${msg}`, JSON.stringify(data));
+  else console.log(`[${ts}] [CONTACT-MGR] ${msg}`);
+}
+
+/**
+ * Get a contact by phone number. Returns null if not found.
+ * @param {string} phone - E.164 phone
+ * @returns {Object|null}
+ */
+function getContact(phone) {
+  const stmts = getStmts();
+  const contact = stmts.getContact.get(normalizePhone(phone));
+  if (!contact) return null;
+  const context = stmts.getContext.get(contact.phone) || {};
+  const scopes = stmts.getAllScopes.all(contact.phone).filter(s => s.granted).map(s => s.scope);
+  return { ...contact, context, scopes };
+}
+
+/**
+ * Get or create a contact. If the contact doesn't exist, creates with defaults.
+ * @param {string} phone - E.164 phone
+ * @param {Object} [defaults] - Default values for new contacts
+ * @returns {Object}
+ */
+function getOrCreateContact(phone, defaults = {}) {
+  const normalized = normalizePhone(phone);
+  let contact = getContact(normalized);
+  if (contact) return contact;
+
+  const stmts = getStmts();
+  const name = defaults.name || 'Unknown';
+  const category = defaults.category || 'unknown';
+  const source = defaults.source || 'unknown';
+
+  stmts.upsertContact.run(normalized, name, category, 'auto', 'casual', '', source, 0, 0, 'none');
+  stmts.upsertContext.run(normalized, '', '', '[]', '', '{}');
+
+  // Apply default scopes for category
+  const categoryScopes = DEFAULT_SCOPES[category] || DEFAULT_SCOPES.unknown;
+  for (const scope of categoryScopes) {
+    stmts.upsertScope.run(normalized, scope, 1, 'auto');
+  }
+
+  log('Created new contact', { phone: normalized, name, category, source });
+  return getContact(normalized);
+}
+
+/**
+ * Update a contact's fields.
+ * @param {string} phone - E.164 phone
+ * @param {Object} updates - Fields to update
+ * @returns {Object|null} Updated contact
+ */
+function updateContact(phone, updates) {
+  const normalized = normalizePhone(phone);
+  const existing = getContact(normalized);
+  if (!existing) return null;
+
+  const stmts = getStmts();
+  stmts.upsertContact.run(
+    normalized,
+    updates.name ?? existing.name,
+    updates.category ?? existing.category,
+    updates.response_mode ?? existing.response_mode,
+    updates.style ?? existing.style,
+    updates.instructions ?? existing.instructions,
+    updates.source ?? existing.source,
+    updates.introduced ?? existing.introduced,
+    updates.qualification_score ?? existing.qualification_score,
+    updates.pipeline_stage ?? existing.pipeline_stage,
+  );
+
+  // If category changed, apply new default scopes
+  if (updates.category && updates.category !== existing.category) {
+    applyDefaultScopes(normalized, updates.category);
+  }
+
+  log('Updated contact', { phone: normalized, updates: Object.keys(updates) });
+  return getContact(normalized);
+}
+
+/**
+ * Update contact context.
+ * @param {string} phone - E.164 phone
+ * @param {Object} contextUpdates
+ */
+function updateContext(phone, contextUpdates) {
+  const normalized = normalizePhone(phone);
+  const stmts = getStmts();
+  const existing = stmts.getContext.get(normalized) || {};
+
+  stmts.upsertContext.run(
+    normalized,
+    contextUpdates.relationship ?? existing.relationship ?? '',
+    contextUpdates.last_topic ?? existing.last_topic ?? '',
+    contextUpdates.pending_items ?? existing.pending_items ?? '[]',
+    contextUpdates.conversation_summary ?? existing.conversation_summary ?? '',
+    contextUpdates.preferences ?? existing.preferences ?? '{}',
+  );
+}
+
+/**
+ * Delete a contact and all associated data.
+ * @param {string} phone - E.164 phone
+ * @returns {boolean}
+ */
+function deleteContact(phone) {
+  const normalized = normalizePhone(phone);
+  const stmts = getStmts();
+  stmts.deleteContext.run(normalized);
+  stmts.deleteScopesByPhone.run(normalized);
+  stmts.deleteContact.run(normalized);
+  log('Deleted contact', { phone: normalized });
+  return true;
+}
+
+/**
+ * Get all contacts, optionally filtered.
+ * @param {Object} [filter] - { category, search }
+ * @returns {Array}
+ */
+function listContacts(filter = {}) {
+  const stmts = getStmts();
+  if (filter.category) {
+    return stmts.filterByCategory.all(filter.category);
+  }
+  if (filter.search) {
+    const q = `%${filter.search}%`;
+    return stmts.searchContacts.all(q, q);
+  }
+  return stmts.getAllContacts.all();
+}
+
+/**
+ * Apply default scopes for a category. Does NOT revoke existing scopes.
+ * @param {string} phone
+ * @param {string} category
+ */
+function applyDefaultScopes(phone, category) {
+  const stmts = getStmts();
+  const scopes = DEFAULT_SCOPES[category] || DEFAULT_SCOPES.unknown;
+  for (const scope of scopes) {
+    stmts.upsertScope.run(phone, scope, 1, 'auto');
+  }
+}
+
+/**
+ * Set specific scopes for a contact.
+ * @param {string} phone
+ * @param {Object} scopeMap - { 'calendar.book': true, 'info.personal': false }
+ */
+function setScopes(phone, scopeMap) {
+  const normalized = normalizePhone(phone);
+  const stmts = getStmts();
+  for (const [scope, granted] of Object.entries(scopeMap)) {
+    stmts.upsertScope.run(normalized, scope, granted ? 1 : 0, 'manual');
+  }
+}
+
+/**
+ * Check if a contact has a specific scope.
+ * @param {string} phone
+ * @param {string} scope
+ * @returns {boolean}
+ */
+function hasScope(phone, scope) {
+  const stmts = getStmts();
+  const row = stmts.getScope.get(normalizePhone(phone), scope);
+  return row?.granted === 1;
+}
+
+/**
+ * Mark a contact as introduced by AIVA.
+ * @param {string} phone
+ */
+function markIntroduced(phone) {
+  getStmts().markIntroduced.run(normalizePhone(phone));
+}
+
+/**
+ * Update qualification score and pipeline stage.
+ * @param {string} phone
+ * @param {number} score - 0-100
+ * @param {string} stage - none, cold, warm, hot, qualified, client
+ */
+function updateQualification(phone, score, stage) {
+  getStmts().updateQualification.run(score, stage, normalizePhone(phone));
+}
+
+/**
+ * Check if the last outbound message was sent by Brandon (for reintro logic).
+ * @param {string} phone
+ * @returns {boolean}
+ */
+function needsReintro(phone) {
+  const row = getStmts().getLastSentBy.get(normalizePhone(phone));
+  return row && row.sent_by === 'brandon';
+}
+
+module.exports = {
+  getContact,
+  getOrCreateContact,
+  updateContact,
+  updateContext,
+  deleteContact,
+  listContacts,
+  applyDefaultScopes,
+  setScopes,
+  hasScope,
+  markIntroduced,
+  updateQualification,
+  needsReintro,
+  DEFAULT_SCOPES,
+};