@conversionpros/aiva 1.0.0

package/lib/setup.js

@@ -0,0 +1,472 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const pc = require('picocolors');
+const prompts = require('prompts');
+const { saveConfig, ensureDirectories, getAivaHome, getWorkspaceDir, loadConfig } = require('./config');
+const { writeEcosystem, ensurePm2, startServer } = require('./process');
+const { checkHealth } = require('./health');
+
+const TEMPLATES_DIR = path.join(__dirname, '..', 'templates', 'workspace');
+
+function renderTemplate(templatePath, vars) {
+  let content = fs.readFileSync(templatePath, 'utf8');
+  for (const [key, value] of Object.entries(vars)) {
+    const regex = new RegExp(`\\{\\{${key}\\}\\}`, 'g');
+    content = content.replace(regex, value || '');
+  }
+  return content;
+}
+
+function banner() {
+  console.log();
+  console.log(pc.cyan(pc.bold('  ╔═══════════════════════════════════╗')));
+  console.log(pc.cyan(pc.bold('  ║         AIVA Setup Wizard         ║')));
+  console.log(pc.cyan(pc.bold('  ║     AI Virtual Assistant v1.0     ║')));
+  console.log(pc.cyan(pc.bold('  ╚═══════════════════════════════════╝')));
+  console.log();
+}
+
+function checkNodeVersion() {
+  const major = parseInt(process.versions.node.split('.')[0], 10);
+  if (major < 18) {
+    console.error(pc.red(`Node.js 18+ required. You have ${process.versions.node}`));
+    process.exit(1);
+  }
+}
+
+const STYLE_MAP = {
+  'Professional & formal': 'Professional, formal, and polished. Every communication is precise and well-structured.',
+  'Casual & friendly': 'Casual, friendly, and approachable. Conversational tone with genuine warmth.',
+  'Direct & efficient': 'Direct, efficient, and no-nonsense. Lead with the answer, skip the fluff.',
+  'Warm & supportive': 'Warm, supportive, and encouraging. Empathetic while still getting things done.'
+};
+
+const TECH_LEVEL_CONFIG = {
+  power: {
+    communicationGuidance: 'Concise and direct. Lead with the answer, skip the explanation unless asked. Present options with brief trade-offs, let them decide fast. Never explain basic tech concepts. Assume competence.',
+    decisionStyle: 'Present the top recommendation with reasoning. Only elaborate if asked. Use interactive questionnaires for complex decisions with 3+ options only.',
+    autonomyLevel: 'Act first, report after. Only escalate truly ambiguous decisions or anything with financial, legal, or external impact. Routine operations never need permission.',
+    coachingNotes: 'Your human is technically sharp. Be a peer, not a teacher. When something goes wrong, lead with the fix, not the explanation.',
+    soulAddition: 'Your human is a power user. They want results, not narration. Respect their time and intelligence. Skip the hand-holding entirely.'
+  },
+  comfortable: {
+    communicationGuidance: 'Clear and efficient. Provide enough context to make informed decisions without overwhelming detail. Use plain language for technical concepts but do not over-explain.',
+    decisionStyle: 'Present 2-3 options with clear pros and cons. Make a recommendation but give them the choice. Use interactive questionnaires for any decision with 2+ options.',
+    autonomyLevel: 'Brief heads-up before significant actions. Report results with a one-line summary of what happened and why it matters.',
+    coachingNotes: 'Your human is capable but not deeply technical. Give the "why" alongside the "what" so they build understanding over time. When something goes wrong, explain what happened in plain terms, what you did about it, and whether they need to do anything.',
+    soulAddition: 'Your human is comfortable with tech but appreciates context. Build their understanding naturally over time without being condescending.'
+  },
+  guided: {
+    communicationGuidance: 'Patient and thorough. Explain what you are doing and why before doing it. Use analogies and plain language - never assume technical knowledge. Proactively explain implications of decisions.',
+    decisionStyle: 'Walk them through each decision step by step. Explain trade-offs in everyday terms. Make strong recommendations with clear reasoning. Use interactive questionnaires for every decision point, even binary ones.',
+    autonomyLevel: 'Always explain what you plan to do before doing it. After completing a task, explain what was done and what it means for them in plain language. Never act silently on anything that affects their business.',
+    coachingNotes: 'Your human needs you to be their tech translator. Every interaction is a chance to build their confidence. Never make them feel dumb for not knowing something. When something goes wrong, reassure first, then explain simply, then describe the fix. They need to feel safe that you have got it handled. Proactively teach them things that will help them use technology better over time. Be a coach, not just an executor.',
+    soulAddition: 'Your human trusts you to navigate technology for them. Be their guide. Celebrate their wins. Make complex things feel simple. Your patience is a feature, not a limitation.'
+  }
+};
+
+const EMOJI_MAP = {
+  'lightning bolt': String.fromCodePoint(0x26A1),
+  'star': String.fromCodePoint(0x2B50),
+  'rocket': String.fromCodePoint(0x1F680),
+  'sparkles': String.fromCodePoint(0x2728),
+  'brain': String.fromCodePoint(0x1F9E0),
+  'fire': String.fromCodePoint(0x1F525)
+};
+
+async function run(opts = {}) {
+  banner();
+  checkNodeVersion();
+
+  const detectedTz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+
+  // ── Section 1: Server Configuration ──
+  console.log(pc.bold('  Server Configuration'));
+  console.log(pc.dim('  ─'.repeat(20)));
+
+  const serverAnswers = await prompts([
+    {
+      type: 'number',
+      name: 'port',
+      message: 'Which port should the server run on?',
+      initial: parseInt(opts.port, 10) || 3847
+    },
+    {
+      type: 'text',
+      name: 'gatewayUrl',
+      message: 'OpenClaw Gateway URL?',
+      initial: 'http://localhost:3033'
+    },
+    {
+      type: 'password',
+      name: 'gatewayPassword',
+      message: 'Gateway auth password?'
+    }
+  ], { onCancel: () => { console.log(pc.yellow('\nSetup cancelled.')); process.exit(0); } });
+
+  console.log();
+
+  // ── Section 2: Client Profile ──
+  console.log(pc.bold('  Client Profile'));
+  console.log(pc.dim('  ─'.repeat(20)));
+
+  const clientAnswers = await prompts([
+    {
+      type: 'text',
+      name: 'fullName',
+      message: "What's the client's full name?",
+      validate: v => v.trim() ? true : 'Name is required'
+    },
+    {
+      type: 'text',
+      name: 'nickname',
+      message: 'What should AIVA call them?',
+      initial: prev => prev.split(' ')[0]
+    },
+    {
+      type: 'select',
+      name: 'pronouns',
+      message: 'Their pronouns?',
+      choices: [
+        { title: 'he/him', value: 'he/him' },
+        { title: 'she/her', value: 'she/her' },
+        { title: 'they/them', value: 'they/them' },
+        { title: 'other', value: 'other' }
+      ]
+    },
+    {
+      type: prev => prev === 'other' ? 'text' : null,
+      name: 'customPronouns',
+      message: 'Enter pronouns:'
+    },
+    {
+      type: 'text',
+      name: 'timezone',
+      message: 'Their timezone?',
+      initial: detectedTz
+    },
+    {
+      type: 'text',
+      name: 'email',
+      message: 'Their email address?',
+      validate: v => v.includes('@') ? true : 'Enter a valid email'
+    },
+    {
+      type: 'text',
+      name: 'phone',
+      message: 'Their phone number? (optional)',
+      initial: ''
+    },
+    {
+      type: 'text',
+      name: 'business',
+      message: 'Business name? (optional)',
+      initial: ''
+    },
+    {
+      type: 'text',
+      name: 'businessDescription',
+      message: 'Brief description of what they do? (optional)',
+      initial: ''
+    }
+  ], { onCancel: () => { console.log(pc.yellow('\nSetup cancelled.')); process.exit(0); } });
+
+  console.log();
+
+  // ── Section 3: AIVA Personality ──
+  console.log(pc.bold('  AIVA Personality'));
+  console.log(pc.dim('  ─'.repeat(20)));
+
+  const personalityAnswers = await prompts([
+    {
+      type: 'text',
+      name: 'aivaName',
+      message: 'What should this AIVA be named?',
+      initial: opts.name || 'AIVA'
+    },
+    {
+      type: 'select',
+      name: 'style',
+      message: 'Communication style?',
+      choices: [
+        { title: 'Professional & formal', value: 'Professional & formal' },
+        { title: 'Casual & friendly', value: 'Casual & friendly' },
+        { title: 'Direct & efficient', value: 'Direct & efficient' },
+        { title: 'Warm & supportive', value: 'Warm & supportive' }
+      ]
+    },
+    {
+      type: 'select',
+      name: 'emoji',
+      message: "AIVA's signature emoji?",
+      choices: [
+        { title: `${EMOJI_MAP['lightning bolt']} Lightning bolt`, value: 'lightning bolt' },
+        { title: `${EMOJI_MAP['star']} Star`, value: 'star' },
+        { title: `${EMOJI_MAP['rocket']} Rocket`, value: 'rocket' },
+        { title: `${EMOJI_MAP['sparkles']} Sparkles`, value: 'sparkles' },
+        { title: `${EMOJI_MAP['brain']} Brain`, value: 'brain' },
+        { title: `${EMOJI_MAP['fire']} Fire`, value: 'fire' }
+      ]
+    }
+  ], { onCancel: () => { console.log(pc.yellow('\nSetup cancelled.')); process.exit(0); } });
+
+  // ── Section 4: Tech Sophistication ──
+  console.log(pc.bold('  Client Sophistication'));
+  console.log(pc.dim('  ─'.repeat(20)));
+
+  const techAnswers = await prompts([
+    {
+      type: 'select',
+      name: 'techLevel',
+      message: 'How tech-savvy is this person?',
+      choices: [
+        { title: 'Power User - Knows tech, wants concise updates, hates hand-holding', value: 'power' },
+        { title: 'Comfortable - Uses tech daily but not technical, needs context not tutorials', value: 'comfortable' },
+        { title: 'Guided - Needs step-by-step coaching, plain language, proactive guidance', value: 'guided' }
+      ]
+    }
+  ], { onCancel: () => { console.log(pc.yellow('\nSetup cancelled.')); process.exit(0); } });
+
+  console.log();
+
+  // ── Build config ──
+  const pronouns = clientAnswers.pronouns === 'other'
+    ? (clientAnswers.customPronouns || 'they/them')
+    : clientAnswers.pronouns;
+
+  const config = {
+    name: personalityAnswers.aivaName,
+    owner: clientAnswers.nickname,
+    port: serverAnswers.port,
+    gateway: {
+      url: serverAnswers.gatewayUrl,
+      password: serverAnswers.gatewayPassword
+    },
+    techLevel: techAnswers.techLevel,
+    autoStart: true,
+    installedAt: new Date().toISOString(),
+    client: {
+      fullName: clientAnswers.fullName,
+      nickname: clientAnswers.nickname,
+      pronouns,
+      timezone: clientAnswers.timezone,
+      email: clientAnswers.email,
+      phone: clientAnswers.phone || '',
+      business: clientAnswers.business || '',
+      businessDescription: clientAnswers.businessDescription || ''
+    },
+    personality: {
+      name: personalityAnswers.aivaName,
+      style: personalityAnswers.style,
+      emoji: personalityAnswers.emoji
+    }
+  };
+
+  // ── Create directories ──
+  console.log(pc.cyan('  Creating directories...'));
+  ensureDirectories();
+
+  // Create memory subdirectory
+  const memoryDir = path.join(getWorkspaceDir(), 'memory');
+  if (!fs.existsSync(memoryDir)) fs.mkdirSync(memoryDir, { recursive: true });
+
+  // ── Save config ──
+  console.log(pc.cyan('  Saving configuration...'));
+  saveConfig(config);
+
+  // ── Generate workspace files ──
+  console.log(pc.cyan('  Generating workspace files...'));
+  const templateVars = {
+    clientName: clientAnswers.fullName,
+    clientNickname: clientAnswers.nickname,
+    clientPronouns: pronouns,
+    clientTimezone: clientAnswers.timezone,
+    clientEmail: clientAnswers.email,
+    clientPhone: clientAnswers.phone || '(not provided)',
+    businessName: clientAnswers.business || '(not provided)',
+    businessDescription: clientAnswers.businessDescription || '(not provided)',
+    aivaName: personalityAnswers.aivaName,
+    aivaEmoji: EMOJI_MAP[personalityAnswers.emoji] || EMOJI_MAP['lightning bolt'],
+    communicationStyle: STYLE_MAP[personalityAnswers.style] || personalityAnswers.style,
+    techLevel: techAnswers.techLevel,
+    communicationGuidance: TECH_LEVEL_CONFIG[techAnswers.techLevel].communicationGuidance,
+    decisionStyle: TECH_LEVEL_CONFIG[techAnswers.techLevel].decisionStyle,
+    autonomyLevel: TECH_LEVEL_CONFIG[techAnswers.techLevel].autonomyLevel,
+    coachingNotes: TECH_LEVEL_CONFIG[techAnswers.techLevel].coachingNotes,
+    soulAddition: TECH_LEVEL_CONFIG[techAnswers.techLevel].soulAddition
+  };
+
+  const workspaceDir = getWorkspaceDir();
+  const templateFiles = [
+    { template: 'IDENTITY.md.tmpl', output: 'IDENTITY.md' },
+    { template: 'USER.md.tmpl', output: 'USER.md' },
+    { template: 'AGENTS.md.tmpl', output: 'AGENTS.md' },
+    { template: 'SOUL.md.tmpl', output: 'SOUL.md' },
+    { template: 'MEMORY.md.tmpl', output: 'MEMORY.md' },
+    { template: 'HEARTBEAT.md.tmpl', output: 'HEARTBEAT.md' }
+  ];
+
+  for (const { template, output } of templateFiles) {
+    const tmplPath = path.join(TEMPLATES_DIR, template);
+    if (fs.existsSync(tmplPath)) {
+      const rendered = renderTemplate(tmplPath, templateVars);
+      const outPath = path.join(workspaceDir, output);
+      // Don't overwrite existing files (preserve user edits on re-setup)
+      if (!fs.existsSync(outPath)) {
+        fs.writeFileSync(outPath, rendered);
+        console.log(pc.dim(`    Created ${output}`));
+      } else {
+        console.log(pc.dim(`    Skipped ${output} (already exists)`));
+      }
+    }
+  }
+
+  // ── Check/install PM2 ──
+  console.log(pc.cyan('  Checking PM2...'));
+  ensurePm2();
+
+  // ── Write PM2 ecosystem ──
+  console.log(pc.cyan('  Writing PM2 ecosystem config...'));
+  writeEcosystem();
+
+  // ── Auto-start setup ──
+  const platform = process.platform;
+  if (config.autoStart) {
+    if (platform === 'darwin') {
+      await setupLaunchd(config);
+    } else if (platform === 'linux') {
+      await setupSystemd(config);
+    }
+  }
+
+  // ── Start server ──
+  console.log(pc.cyan('  Starting AIVA...'));
+  await startServer();
+
+  // ── Health check ──
+  await new Promise(r => setTimeout(r, 3000));
+  const health = await checkHealth(config.port);
+
+  // ── Success banner ──
+  console.log();
+  console.log(pc.green(pc.bold('  ╔═══════════════════════════════════╗')));
+  console.log(pc.green(pc.bold(`  ║   ${personalityAnswers.aivaName} is ready! ${EMOJI_MAP[personalityAnswers.emoji] || ''}`)));
+  console.log(pc.green(pc.bold('  ╚═══════════════════════════════════╝')));
+  console.log();
+  console.log(`  ${pc.bold('URL:')}         http://localhost:${config.port}`);
+  console.log(`  ${pc.bold('Config:')}      ${path.join(getAivaHome(), 'config.json')}`);
+  console.log(`  ${pc.bold('Workspace:')}   ${workspaceDir}`);
+  console.log(`  ${pc.bold('Data:')}        ${path.join(getAivaHome(), 'data')}`);
+  console.log(`  ${pc.bold('Logs:')}        ${path.join(getAivaHome(), 'logs')}`);
+  console.log(`  ${pc.bold('Health:')}      ${health.ok ? pc.green('Healthy') : pc.yellow('Starting up...')}`);
+  console.log();
+  console.log(pc.dim('  Commands:'));
+  console.log(pc.dim('    aiva status    - Check server status'));
+  console.log(pc.dim('    aiva logs      - View server logs'));
+  console.log(pc.dim('    aiva restart   - Restart server'));
+  console.log(pc.dim('    aiva stop      - Stop server'));
+  console.log();
+}
+
+async function setupLaunchd(config) {
+  const plistPath = path.join(
+    process.env.HOME || require('os').homedir(),
+    'Library', 'LaunchAgents', 'com.conversionpros.aiva.plist'
+  );
+
+  // Find the aiva binary
+  let aivaBin;
+  try {
+    aivaBin = require('child_process').execSync('which aiva', { stdio: 'pipe' }).toString().trim();
+  } catch {
+    aivaBin = path.join(__dirname, '..', 'bin', 'aiva.js');
+  }
+
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.conversionpros.aiva</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${process.execPath}</string>
+    <string>${aivaBin}</string>
+    <string>start</string>
+    <string>--foreground</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${path.join(getAivaHome(), 'logs', 'aiva-launchd.log')}</string>
+  <key>StandardErrorPath</key>
+  <string>${path.join(getAivaHome(), 'logs', 'aiva-launchd-error.log')}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>AIVA_HOME</key>
+    <string>${getAivaHome()}</string>
+    <key>PORT</key>
+    <string>${config.port}</string>
+  </dict>
+</dict>
+</plist>`;
+
+  const { confirm } = await prompts({
+    type: 'confirm',
+    name: 'confirm',
+    message: 'Set up auto-start on login (launchd)?',
+    initial: true
+  });
+
+  if (confirm) {
+    const dir = path.dirname(plistPath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(plistPath, plist);
+    console.log(pc.dim(`    Created ${plistPath}`));
+  }
+}
+
+async function setupSystemd(config) {
+  const { confirm } = await prompts({
+    type: 'confirm',
+    name: 'confirm',
+    message: 'Generate systemd service file for auto-start?',
+    initial: true
+  });
+
+  if (!confirm) return;
+
+  let aivaBin;
+  try {
+    aivaBin = require('child_process').execSync('which aiva', { stdio: 'pipe' }).toString().trim();
+  } catch {
+    aivaBin = path.join(__dirname, '..', 'bin', 'aiva.js');
+  }
+
+  const service = `[Unit]
+Description=AIVA - AI Virtual Assistant
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${process.execPath} ${aivaBin} start --foreground
+Restart=on-failure
+RestartSec=5
+Environment=AIVA_HOME=${getAivaHome()}
+Environment=PORT=${config.port}
+
+[Install]
+WantedBy=default.target
+`;
+
+  const servicePath = path.join(getAivaHome(), 'aiva.service');
+  fs.writeFileSync(servicePath, service);
+  console.log(pc.dim(`    Wrote systemd service to ${servicePath}`));
+  console.log(pc.dim('    To install: systemctl --user enable --now ' + servicePath));
+}
+
+module.exports = { run };

package/meta-capi.js

@@ -0,0 +1,206 @@
+/**
+ * Meta Conversions API (CAPI) Module
+ * Sends server-side events to Meta for optimization signals.
+ */
+const crypto = require('crypto');
+const https = require('https');
+
+const PIXEL_ID = process.env.META_PIXEL_ID || '1257861836285895';
+const ACCESS_TOKEN = process.env.META_ACCESS_TOKEN;
+const API_VERSION = 'v21.0';
+
+if (!ACCESS_TOKEN) {
+  console.warn('[meta-capi] META_ACCESS_TOKEN not set - CAPI events will fail');
+}
+
+function sha256(value) {
+  if (!value) return undefined;
+  return crypto.createHash('sha256').update(String(value).toLowerCase().trim()).digest('hex');
+}
+
+function generateEventId() {
+  return crypto.randomUUID();
+}
+
+/**
+ * Send an event to Meta Conversions API.
+ * @param {string} eventName - Lead, Schedule, Purchase, ViewContent, etc.
+ * @param {object} eventData - { sourceUrl, customData, actionSource }
+ * @param {object} userData  - { email, phone, firstName, lastName, ... } (raw, will be hashed)
+ * @returns {Promise<object>}
+ */
+async function sendEvent(eventName, eventData = {}, userData = {}) {
+  const eventId = generateEventId();
+  const eventTime = Math.floor(Date.now() / 1000);
+
+  const hashedUserData = {};
+  if (userData.email) hashedUserData.em = [sha256(userData.email)];
+  if (userData.phone) hashedUserData.ph = [sha256(userData.phone.replace(/\D/g, ''))];
+  if (userData.firstName) hashedUserData.fn = [sha256(userData.firstName)];
+  if (userData.lastName) hashedUserData.ln = [sha256(userData.lastName)];
+  if (userData.city) hashedUserData.ct = [sha256(userData.city)];
+  if (userData.state) hashedUserData.st = [sha256(userData.state)];
+  if (userData.zip) hashedUserData.zp = [sha256(userData.zip)];
+  if (userData.country) hashedUserData.country = [sha256(userData.country)];
+  if (userData.clientIpAddress) hashedUserData.client_ip_address = userData.clientIpAddress;
+  if (userData.clientUserAgent) hashedUserData.client_user_agent = userData.clientUserAgent;
+  if (userData.fbc) hashedUserData.fbc = userData.fbc;
+  if (userData.fbp) hashedUserData.fbp = userData.fbp;
+
+  const payload = {
+    data: [
+      {
+        event_name: eventName,
+        event_time: eventTime,
+        event_id: eventId,
+        action_source: eventData.actionSource || 'website',
+        event_source_url: eventData.sourceUrl || 'https://www.conversionmarketingpros.com',
+        user_data: hashedUserData,
+        ...(eventData.customData ? { custom_data: eventData.customData } : {}),
+      },
+    ],
+    ...(eventData.testEventCode ? { test_event_code: eventData.testEventCode } : {}),
+  };
+
+  const body = JSON.stringify(payload);
+  const token = ACCESS_TOKEN;
+
+  return new Promise((resolve, reject) => {
+    const req = https.request(
+      {
+        hostname: 'graph.facebook.com',
+        path: `/${API_VERSION}/${PIXEL_ID}/events?access_token=${encodeURIComponent(token)}`,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+      },
+      (res) => {
+        let data = '';
+        res.on('data', (chunk) => (data += chunk));
+        res.on('end', () => {
+          try {
+            const parsed = JSON.parse(data);
+            console.log(`[meta-capi] ${eventName} sent | event_id=${eventId} | status=${res.statusCode} | events_received=${parsed.events_received ?? '?'}`);
+            resolve({ ok: res.statusCode === 200, eventId, response: parsed });
+          } catch (e) {
+            console.error(`[meta-capi] Parse error: ${data}`);
+            reject(e);
+          }
+        });
+      }
+    );
+    req.on('error', reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+/**
+ * Express router factory for CAPI webhook endpoints.
+ */
+function createRouter(express) {
+  const router = express.Router();
+
+  // Auth middleware - accept internal header or webhook secret
+  const WEBHOOK_SECRET = process.env.META_CAPI_WEBHOOK_SECRET || 'capi-webhook-2026';
+  router.use((req, res, next) => {
+    if (
+      req.headers['x-aiva-internal'] === 'true' ||
+      req.headers['x-webhook-secret'] === WEBHOOK_SECRET ||
+      req.method === 'GET' // allow test endpoint
+    ) {
+      return next();
+    }
+    return res.status(401).json({ error: 'Unauthorized' });
+  });
+
+  // Extract contact info from GHL webhook payload
+  function extractContact(body) {
+    // GHL sends contact data in various shapes
+    const contact = body.contact || body;
+    return {
+      email: contact.email || body.email,
+      phone: contact.phone || body.phone,
+      firstName: contact.firstName || contact.first_name || body.firstName || body.first_name,
+      lastName: contact.lastName || contact.last_name || body.lastName || body.last_name,
+      city: contact.city || body.city,
+      state: contact.state || body.state,
+      country: contact.country || body.country,
+    };
+  }
+
+  // POST /api/meta/capi/lead
+  router.post('/lead', async (req, res) => {
+    try {
+      const userData = extractContact(req.body);
+      const result = await sendEvent('Lead', {
+        sourceUrl: req.body.source_url || 'https://www.conversionmarketingpros.com',
+        actionSource: 'website',
+      }, userData);
+      console.log(`[meta-capi] Lead webhook processed | email=${userData.email || 'none'}`);
+      res.json({ ok: true, eventId: result.eventId });
+    } catch (err) {
+      console.error('[meta-capi] Lead error:', err.message);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // POST /api/meta/capi/schedule
+  router.post('/schedule', async (req, res) => {
+    try {
+      const userData = extractContact(req.body);
+      const result = await sendEvent('Schedule', {
+        sourceUrl: req.body.source_url || 'https://www.conversionmarketingpros.com',
+        actionSource: 'website',
+      }, userData);
+      console.log(`[meta-capi] Schedule webhook processed | email=${userData.email || 'none'}`);
+      res.json({ ok: true, eventId: result.eventId });
+    } catch (err) {
+      console.error('[meta-capi] Schedule error:', err.message);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // POST /api/meta/capi/purchase
+  router.post('/purchase', async (req, res) => {
+    try {
+      const userData = extractContact(req.body);
+      const result = await sendEvent('Purchase', {
+        sourceUrl: req.body.source_url || 'https://www.conversionmarketingpros.com',
+        actionSource: 'system_generated',
+        customData: {
+          currency: 'USD',
+          value: req.body.value || req.body.monetary_value || 0,
+        },
+      }, userData);
+      console.log(`[meta-capi] Purchase webhook processed | email=${userData.email || 'none'} | value=${req.body.value || 0}`);
+      res.json({ ok: true, eventId: result.eventId });
+    } catch (err) {
+      console.error('[meta-capi] Purchase error:', err.message);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // GET /api/meta/capi/test
+  router.get('/test', async (req, res) => {
+    try {
+      const result = await sendEvent('Lead', {
+        sourceUrl: 'https://www.conversionmarketingpros.com/test',
+        actionSource: 'website',
+        testEventCode: req.query.test_code || undefined,
+      }, {
+        email: 'test@example.com',
+        firstName: 'Test',
+        lastName: 'User',
+        phone: '+15551234567',
+      });
+      res.json({ ok: true, eventId: result.eventId, pixelId: PIXEL_ID, response: result.response });
+    } catch (err) {
+      console.error('[meta-capi] Test error:', err.message);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  return router;
+}
+
+module.exports = { sendEvent, createRouter, sha256, PIXEL_ID: PIXEL_ID };