CRM sync with webhooks

mkdir jelliu-crm-sync && cd jelliu-crm-sync
npm init -y
npm pkg set type=module
npm install express

import crypto from 'node:crypto';
import express from 'express';
const SECRET = process.env.JELLIU_WEBHOOK_SECRET; // "whsec_..."
const PORT = Number(process.env.PORT ?? 3000);
const TOLERANCE_MS = 10 * 60 * 1000;
const MAX_WORKER_TRIES = 5;
if (!SECRET) {
  console.error('Set JELLIU_WEBHOOK_SECRET before starting the receiver.');
  process.exit(1);
}
// In-memory stores keep the example self-contained. In production use a
// database table with a unique constraint, or Redis SET NX with a TTL.
const seenDeliveries = new Map(); // signature -> first seen (ms)
const writtenCalls = new Map(); // "event:callId" -> written at (ms)
const queue = [];
// Map Jelliu outcomes to your CRM's stages. Anything unmapped is "contacted".
const STAGE_BY_OUTCOME = {
  sale_closed: 'won',
  callback_scheduled: 'follow_up',
  appointment_booked: 'meeting_booked',
  rejected: 'lost',
  no_answer: 'not_reached',
  voicemail: 'not_reached',
  failed: 'not_reached',
};
function signatureIsValid(timestamp, rawBody, signature) {
  const expected = crypto
    .createHmac('sha256', SECRET)
    .update(`${timestamp}.${rawBody}`)
    .digest('hex');
  const a = Buffer.from(signature, 'utf8');
  const b = Buffer.from(expected, 'utf8');
  return a.length === b.length && crypto.timingSafeEqual(a, b);
}
const app = express();
app.post('/webhooks/jelliu', express.raw({ type: 'application/json', limit: '1mb' }), (req, res) => {
  const signature = req.get('X-Webhook-Signature-V2') ?? '';
  const timestamp = req.get('X-Webhook-Timestamp') ?? '';
  const attempt = req.get('X-Webhook-Attempt') ?? '1';
  if (!Buffer.isBuffer(req.body)) {
    return res.status(400).json({ error: 'Expected a JSON body' });
  }
  const rawBody = req.body.toString('utf8');
  const sentAt = Date.parse(timestamp);
  if (Number.isNaN(sentAt) || Math.abs(Date.now() - sentAt) > TOLERANCE_MS) {
    return res.status(400).json({ error: 'Timestamp outside tolerance' });
  }
  if (!signatureIsValid(timestamp, rawBody, signature)) {
    return res.status(401).json({ error: 'Invalid signature' });
  }
  if (seenDeliveries.has(signature)) {
    console.log(`Duplicate delivery ignored (attempt ${attempt})`);
    return res.status(200).json({ status: 'duplicate' });
  }
  let event;
  try {
    event = JSON.parse(rawBody);
  } catch {
    return res.status(400).json({ error: 'Malformed JSON' });
  }
  seenDeliveries.set(signature, Date.now());
  queue.push({ event, tries: 0 });
  console.log(`Queued ${event.event} (attempt ${attempt})`);
  return res.status(200).json({ status: 'queued' });
});
async function writeCallToCrm(event) {
  const d = event.data ?? {};
  const record = {
    externalId: `jelliu-call-${d.callId}`,
    phone: d.phoneNumber ?? null,
    stage: STAGE_BY_OUTCOME[d.outcome] ?? 'contacted',
    outcome: d.outcome ?? null,
    summary: d.summary ?? null,
    durationSeconds: d.duration ?? null,
    sentiment: d.sentimentScore ?? null,
    extracted: d.dataCollection ?? null,
    jelliu: { callId: d.callId, contactId: d.contactId, campaignId: d.campaignId, agentId: d.agentId },
    occurredAt: event.timestamp,
  };
  if (!process.env.CRM_API_URL) {
    console.log('CRM write (dry run):', JSON.stringify(record));
    return;
  }
  // Replace with your CRM's upsert call. Keying the write on externalId
  // makes a repeated write update the same record instead of creating one.
  const res = await fetch(`${process.env.CRM_API_URL}/activities/${record.externalId}`, {
    method: 'PUT',
    headers: {
      Authorization: `Bearer ${process.env.CRM_API_TOKEN}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify(record),
    signal: AbortSignal.timeout(15_000),
  });
  if (!res.ok) throw new Error(`CRM responded ${res.status}`);
  console.log(`CRM upserted ${record.externalId}`);
}
async function processEvent(event) {
  switch (event.event) {
    case 'call.completed':
    case 'call.failed': {
      const key = `${event.event}:${event.data?.callId}`;
      if (writtenCalls.has(key)) {
        console.log(`Already written: ${key}`);
        return;
      }
      await writeCallToCrm(event);
      writtenCalls.set(key, Date.now());
      return;
    }
    default:
      console.log(`Ignoring ${event.event}`);
  }
}
let draining = false;
async function drain() {
  if (draining) return;
  draining = true;
  try {
    while (queue.length > 0) {
      const job = queue.shift();
      try {
        await processEvent(job.event);
      } catch (err) {
        job.tries += 1;
        if (job.tries < MAX_WORKER_TRIES) {
          const delayMs = 2 ** job.tries * 1000;
          console.warn(`Write failed (${err.message}); retrying in ${delayMs} ms`);
          setTimeout(() => queue.push(job), delayMs);
        } else {
          console.error(`Giving up on ${job.event.event}:`, err.message);
        }
      }
    }
  } finally {
    draining = false;
  }
}
setInterval(drain, 500);
app.listen(PORT, () => console.log(`Listening on http://localhost:${PORT}/webhooks/jelliu`));

ngrok http 3000

curl -sS -X POST "https://api.jelliu.co/api/webhooks" \
  -H "Authorization: Bearer $JELLIU_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://4f2a-203-0-113-7.ngrok-free.app/webhooks/jelliu",
    "events": ["call.completed", "call.failed"],
    "description": "CRM sync (local test)"
  }'

export JELLIU_WEBHOOK_SECRET="whsec_..."
node server.mjs

// send-test-event.mjs
import crypto from 'node:crypto';
const url = process.argv[2] ?? 'http://localhost:3000/webhooks/jelliu';
const secret = process.env.JELLIU_WEBHOOK_SECRET;
const timestamp = new Date().toISOString();
const body = JSON.stringify({
  event: 'call.completed',
  timestamp,
  data: {
    callId: '5b0d2f7e-9a41-4c3e-8f0a-2c6d1e7b9a10',
    campaignId: '0f3c8b52-6d1a-4e2f-9b7c-4a5e6d7f8a90',
    contactId: 'a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d',
    agentId: '7c1d9f30-5e2a-4a7e-9c8f-91a0b1c2d3e4',
    phoneNumber: '+573001234567',
    outcome: 'callback_scheduled',
    sentimentScore: 0.6,
    duration: 184,
    summary: 'El cliente pidió que lo llamen el jueves en la tarde.',
    dataCollection: { preferred_time: 'jueves en la tarde' },
    kpiData: null,
  },
});
const signature = crypto.createHmac('sha256', secret).update(`${timestamp}.${body}`).digest('hex');
// Send the same delivery twice, the way a retry would arrive.
for (const attempt of [1, 2]) {
  const res = await fetch(url, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-Webhook-Event': 'call.completed',
      'X-Webhook-Timestamp': timestamp,
      'X-Webhook-Signature-V2': signature,
      'X-Webhook-Attempt': String(attempt),
    },
    body,
  });
  console.log(res.status, await res.text());
}

curl -sS "https://api.jelliu.co/api/webhooks/b3d1f0e2-7a6c-4e5b-9d8f-1a2b3c4d5e6f/delivery-logs?limit=5" \
  -H "Authorization: Bearer $JELLIU_API_KEY"