elevenlabs-webhook-nodejs 1.0.0

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "elevenlabs-webhook-nodejs",
+  "version": "1.0.0",
+  "description": "ElevenLabs webhook receiver with AI summaries and WhatsApp notifications",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc && cp src/config/agentPrompts.json dist/config/",
+    "start": "node dist/index.js",
+    "dev": "tsx watch src/index.ts",
+    "add:recipient": "tsx scripts/addRecipient.ts",
+    "list:recipients": "tsx scripts/listRecipients.ts",
+    "promote": "npx tsx scripts/promote.ts",
+    "retrigger": "tsx scripts/retrigger.ts",
+    "test:send": "tsx scripts/testSend.ts",
+    "deploy": "docker compose up --build -d",
+    "deploy:logs": "docker compose logs -f",
+    "deploy:stop": "docker compose down"
+  },
+  "dependencies": {
+    "@elevenlabs/elevenlabs-js": "^2.34.0",
+    "@fastify/cors": "^11.2.0",
+    "@fastify/jwt": "^10.0.0",
+    "@google/generative-ai": "^0.1.3",
+    "bcrypt": "^6.0.0",
+    "dotenv": "^16.3.1",
+    "fastify": "^5.7.4",
+    "fastify-plugin": "^5.1.0",
+    "fastify-raw-body": "^5.0.0",
+    "jsonwebtoken": "^9.0.3",
+    "mongoose": "^8.0.0",
+    "node-cron": "^4.2.1",
+    "openai": "^4.20.0",
+    "twilio": "^5.0.0",
+    "winston": "^3.11.0",
+    "ws": "^8.19.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/bcrypt": "^6.0.0",
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/node": "^25.2.1",
+    "@types/node-cron": "^3.0.11",
+    "@types/ws": "^8.18.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}

package/scripts/addRecipient.ts

@@ -0,0 +1,48 @@
+import 'dotenv/config';
+import mongoose from 'mongoose';
+import WhatsAppRecipient from '../src/models/WhatsAppRecipient';
+
+const MONGODB_URI = process.env.MONGODB_URI || 'mongodb://localhost:27017/elevenlabs-webhook';
+
+const args = process.argv.slice(2);
+
+if (args.length < 3) {
+  console.log('Usage: npx tsx scripts/addRecipient.ts <phone_number> <name> <type>');
+  console.log('');
+  console.log('Examples:');
+  console.log('  npx tsx scripts/addRecipient.ts "+905551234567" "Manager" "contact"');
+  console.log('');
+  console.log('Phone numbers should be in E.164 format (with + prefix)');
+  process.exit(1);
+}
+
+const [whatsapp_id, name, type] = args;
+
+async function addRecipient() {
+  try {
+    await mongoose.connect(MONGODB_URI);
+    console.log('Connected to MongoDB');
+
+    const recipient = new WhatsAppRecipient({
+      whatsapp_id,
+      name,
+      type,
+      is_active: true
+    });
+
+    await recipient.save();
+    console.log(`Recipient added: ${name} (${whatsapp_id})`);
+
+    await mongoose.disconnect();
+  } catch (error) {
+    const err = error as { code?: number; message: string };
+    if (err.code === 11000) {
+      console.error('Error: Recipient already exists');
+    } else {
+      console.error('Error:', err.message);
+    }
+    process.exit(1);
+  }
+}
+
+addRecipient();

package/scripts/listRecipients.ts

@@ -0,0 +1,31 @@
+import 'dotenv/config';
+import mongoose from 'mongoose';
+import WhatsAppRecipient from '../src/models/WhatsAppRecipient';
+
+const MONGODB_URI = process.env.MONGODB_URI || 'mongodb://localhost:27017/elevenlabs-webhook';
+
+async function listRecipients() {
+  try {
+    await mongoose.connect(MONGODB_URI);
+
+    const recipients = await WhatsAppRecipient.find();
+
+    if (recipients.length === 0) {
+      console.log('No recipients found.');
+    } else {
+      console.log('Recipients:');
+      console.log('===========');
+      recipients.forEach(r => {
+        const status = r.is_active ? 'active' : 'inactive';
+        console.log(`[${status}] ${r.name} (${r.type}): ${r.whatsapp_id}`);
+      });
+    }
+
+    await mongoose.disconnect();
+  } catch (error) {
+    console.error('Error:', (error as Error).message);
+    process.exit(1);
+  }
+}
+
+listRecipients();

package/scripts/migrate-agent-ref.ts

@@ -0,0 +1,86 @@
+/**
+ * One-time migration: converts tenant.settings.whatsapp_agent.elevenlabs_agent_id (string)
+ * to tenant.settings.whatsapp_agent.agent_id (ObjectId reference to Agent model).
+ *
+ * Usage: npx tsx scripts/migrate-agent-ref.ts [--dry-run]
+ */
+import mongoose from 'mongoose';
+import dotenv from 'dotenv';
+dotenv.config();
+
+const MONGODB_URI = process.env.MONGODB_URI || 'mongodb://localhost:27017/tektip';
+const dryRun = process.argv.includes('--dry-run');
+
+async function main() {
+  await mongoose.connect(MONGODB_URI);
+  console.log(`Connected to MongoDB (dry-run: ${dryRun})`);
+
+  const db = mongoose.connection.db!;
+  const tenants = db.collection('tenants');
+  const agents = db.collection('agents');
+
+  // Find tenants that have the old elevenlabs_agent_id but no agent_id
+  const cursor = tenants.find({
+    'settings.whatsapp_agent.elevenlabs_agent_id': { $ne: null, $exists: true },
+  });
+
+  let migrated = 0;
+  let skipped = 0;
+  let notFound = 0;
+
+  for await (const tenant of cursor) {
+    const oldElId = tenant.settings?.whatsapp_agent?.elevenlabs_agent_id;
+    const existingAgentId = tenant.settings?.whatsapp_agent?.agent_id;
+
+    if (!oldElId) {
+      skipped++;
+      continue;
+    }
+
+    if (existingAgentId) {
+      console.log(`  SKIP ${tenant.name} — already has agent_id=${existingAgentId}`);
+      skipped++;
+      continue;
+    }
+
+    // Find the Agent record: first try exact EL ID match, then fall back to tenant's active agent
+    let agent = await agents.findOne({ elevenlabs_agent_id: oldElId });
+
+    if (!agent) {
+      // EL ID in settings might be outdated — find any active agent for this tenant
+      agent = await agents.findOne({ tenant_id: tenant._id, is_active: true });
+    }
+
+    if (!agent) {
+      console.log(`  NOT FOUND ${tenant.name} — no Agent with elevenlabs_agent_id="${oldElId}" and no active agent for tenant`);
+      notFound++;
+      continue;
+    }
+
+    console.log(`  MIGRATE ${tenant.name} — elevenlabs_agent_id="${oldElId}" → agent_id=${agent._id} (${agent.agent_template} / ${agent.phone_number})`);
+
+    if (!dryRun) {
+      await tenants.updateOne(
+        { _id: tenant._id },
+        {
+          $set: { 'settings.whatsapp_agent.agent_id': agent._id },
+          $unset: { 'settings.whatsapp_agent.elevenlabs_agent_id': '' },
+        },
+      );
+    }
+
+    migrated++;
+  }
+
+  console.log(`\nDone. Migrated: ${migrated}, Skipped: ${skipped}, Agent not found: ${notFound}`);
+  if (dryRun && migrated > 0) {
+    console.log('(dry-run — no changes written. Run without --dry-run to apply.)');
+  }
+
+  await mongoose.disconnect();
+}
+
+main().catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/scripts/migrate-sessions.ts

@@ -0,0 +1,183 @@
+/**
+ * Migration script: chat-centric → session-centric WhatsApp architecture.
+ *
+ * What it does:
+ * 1. Creates WhatsAppSession documents from chats that had active sessions
+ *    (reads old embedded fields: mode, session_status, taken_over_by, etc.)
+ * 2. Backfills session_id on WhatsAppMessage documents
+ * 3. Sets is_closed + active_session_id on WhatsAppChat documents
+ *
+ * Safe to run multiple times (idempotent).
+ *
+ * Usage:
+ *   npx tsx scripts/migrate-sessions.ts
+ *   npx tsx scripts/migrate-sessions.ts --dry-run
+ */
+import mongoose from 'mongoose';
+import dotenv from 'dotenv';
+dotenv.config();
+
+import WhatsAppChat from '../src/modules/whatsapp/whatsapp-chat.model';
+import WhatsAppSession from '../src/modules/whatsapp/whatsapp-session.model';
+import WhatsAppMessage from '../src/modules/whatsapp/whatsapp-message.model';
+
+const MONGODB_URI = process.env.MONGODB_URI || 'mongodb://localhost:27017/tektip';
+const DRY_RUN = process.argv.includes('--dry-run');
+
+async function main() {
+  console.log(`Connecting to ${MONGODB_URI}...`);
+  await mongoose.connect(MONGODB_URI);
+  console.log('Connected.\n');
+
+  if (DRY_RUN) console.log('=== DRY RUN MODE (no writes) ===\n');
+
+  // Step 1: Find all chats (use raw collection to read old fields)
+  const chatCollection = mongoose.connection.collection('whatsappchats');
+  const allChats = await chatCollection.find({}).toArray();
+  console.log(`Found ${allChats.length} chats total.`);
+
+  let sessionsCreated = 0;
+  let messagesUpdated = 0;
+  let chatsUpdated = 0;
+
+  for (const chat of allChats) {
+    const chatId = chat._id;
+    const tenantId = chat.tenant_id;
+
+    // Read old embedded fields (may not exist on new chats)
+    const oldMode = (chat as any).mode as string | undefined;
+    const oldSessionStatus = (chat as any).session_status as string | undefined;
+    const oldSessionStartedAt = (chat as any).session_started_at as Date | null;
+    const oldGraceDeadline = (chat as any).session_grace_deadline as Date | null;
+    const oldResolvedBy = (chat as any).session_resolved_by as string | null;
+    const oldTakenOverBy = (chat as any).taken_over_by as mongoose.Types.ObjectId | null;
+    const oldTakenOverAt = (chat as any).taken_over_at as Date | null;
+    const oldELConversationId = (chat as any).elevenlabs_conversation_id as string | null;
+    const oldELConversationCreatedAt = (chat as any).elevenlabs_conversation_created_at as Date | null;
+    const oldELLastInteractionAt = (chat as any).elevenlabs_last_interaction_at as Date | null;
+
+    // Determine is_closed
+    const isClosed = oldMode === 'closed';
+
+    // Determine if we need to create a session
+    const needsSession = oldSessionStatus === 'waiting' || oldSessionStatus === 'active'
+      || (oldMode === 'ai' && oldSessionStatus !== 'idle' && oldSessionStatus !== 'resolved')
+      || (oldMode === 'human' && oldSessionStatus !== 'idle' && oldSessionStatus !== 'resolved');
+
+    // Also create sessions for resolved sessions (for history)
+    const hadSession = !!(oldSessionStartedAt || oldSessionStatus === 'resolved');
+
+    let activeSessionId: mongoose.Types.ObjectId | null = null;
+
+    // Skip if chat already has active_session_id (already migrated)
+    if (chat.active_session_id) {
+      console.log(`  Chat ${chatId}: already migrated, skipping.`);
+      continue;
+    }
+
+    if (hadSession || needsSession) {
+      // Map old status to new session status
+      let sessionStatus: 'waiting' | 'active' | 'resolved' = 'resolved';
+      if (oldSessionStatus === 'waiting') {
+        sessionStatus = 'waiting';
+      } else if (oldSessionStatus === 'active' || (oldMode === 'ai' && oldSessionStatus !== 'resolved' && oldSessionStatus !== 'idle')) {
+        sessionStatus = 'active';
+      } else {
+        sessionStatus = 'resolved';
+      }
+
+      // Map resolved_by
+      let resolvedBy: 'human' | 'ai_timeout' | 'manual' | null = null;
+      if (sessionStatus === 'resolved') {
+        resolvedBy = (oldResolvedBy as any) || 'manual';
+      }
+
+      const sessionDoc = {
+        chat_id: chatId,
+        tenant_id: tenantId,
+        status: sessionStatus,
+        resolved_by: resolvedBy,
+        started_at: oldSessionStartedAt || chat.createdAt || new Date(),
+        resolved_at: sessionStatus === 'resolved' ? (oldTakenOverAt || new Date()) : null,
+        grace_deadline: oldGraceDeadline || null,
+        taken_over_by: oldTakenOverBy || null,
+        taken_over_at: oldTakenOverAt || null,
+        elevenlabs_conversation_id: oldELConversationId || null,
+        elevenlabs_conversation_created_at: oldELConversationCreatedAt || null,
+        elevenlabs_last_interaction_at: oldELLastInteractionAt || null,
+        message_count: 0,
+      };
+
+      if (!DRY_RUN) {
+        const session = await WhatsAppSession.create(sessionDoc);
+        activeSessionId = sessionStatus !== 'resolved' ? session._id : null;
+
+        // Backfill session_id on messages created since session start
+        const messageFilter: any = {
+          chat_id: chatId,
+          session_id: null, // only update messages not yet assigned
+        };
+        if (oldSessionStartedAt) {
+          messageFilter.createdAt = { $gte: oldSessionStartedAt };
+        }
+
+        const msgResult = await WhatsAppMessage.updateMany(
+          messageFilter,
+          { $set: { session_id: session._id } }
+        );
+        messagesUpdated += msgResult.modifiedCount;
+
+        // Update message_count on session
+        const sessionMessageCount = await WhatsAppMessage.countDocuments({ session_id: session._id });
+        await WhatsAppSession.updateOne({ _id: session._id }, { message_count: sessionMessageCount });
+
+        sessionsCreated++;
+      } else {
+        sessionsCreated++;
+        console.log(`  Would create session for chat ${chatId}: status=${sessionStatus}`);
+      }
+    }
+
+    // Update chat: set is_closed + active_session_id
+    if (!DRY_RUN) {
+      await chatCollection.updateOne(
+        { _id: chatId },
+        {
+          $set: {
+            is_closed: isClosed,
+            active_session_id: activeSessionId,
+          },
+          $unset: {
+            mode: '',
+            session_status: '',
+            session_started_at: '',
+            session_grace_deadline: '',
+            session_resolved_by: '',
+            taken_over_by: '',
+            taken_over_at: '',
+            elevenlabs_conversation_id: '',
+            elevenlabs_conversation_created_at: '',
+            elevenlabs_last_interaction_at: '',
+          },
+        }
+      );
+      chatsUpdated++;
+    } else {
+      chatsUpdated++;
+    }
+  }
+
+  console.log('\n=== Migration Summary ===');
+  console.log(`Sessions created: ${sessionsCreated}`);
+  console.log(`Messages updated: ${messagesUpdated}`);
+  console.log(`Chats updated: ${chatsUpdated}`);
+  if (DRY_RUN) console.log('(DRY RUN — no actual changes made)');
+
+  await mongoose.disconnect();
+  console.log('\nDone.');
+}
+
+main().catch(err => {
+  console.error('Migration failed:', err);
+  process.exit(1);
+});

package/scripts/promote.ts

@@ -0,0 +1,27 @@
+import mongoose from 'mongoose';
+import dotenv from 'dotenv';
+dotenv.config();
+import User from '../src/modules/auth/auth.model';
+
+async function main() {
+  const email = process.argv[2];
+  if (!email) {
+    console.log('Usage: npx tsx scripts/promote.ts <email>');
+    process.exit(1);
+  }
+
+  await mongoose.connect(process.env.MONGODB_URI || '');
+  const user = await User.findOne({ email: email.toLowerCase() });
+  if (!user) {
+    console.log(`No user found with email: ${email}`);
+    await mongoose.disconnect();
+    process.exit(1);
+  }
+
+  console.log('Current:', user.email, user.role);
+  user.role = 'superadmin';
+  await user.save();
+  console.log('Updated:', user.email, '→ superadmin');
+  await mongoose.disconnect();
+}
+main();

package/scripts/retrigger.ts

@@ -0,0 +1,84 @@
+import 'dotenv/config';
+import mongoose from 'mongoose';
+import Transcription from '../src/models/Transcription';
+import Summary from '../src/models/Summary';
+import { createAIService } from '../src/services/ai';
+import whatsappService from '../src/services/whatsapp.service';
+
+const MONGODB_URI = process.env.MONGODB_URI || 'mongodb://localhost:27017/elevenlabs-webhook';
+
+async function retrigger() {
+  try {
+    await mongoose.connect(MONGODB_URI);
+    console.log('Connected to MongoDB');
+
+    console.log('Initializing WhatsApp client...');
+    await whatsappService.initialize();
+
+    await new Promise<void>((resolve) => {
+      const check = setInterval(() => {
+        if (whatsappService.isReady) {
+          clearInterval(check);
+          resolve();
+        }
+      }, 1000);
+    });
+    console.log('WhatsApp ready');
+
+    const transcription = await Transcription.findOne().sort({ createdAt: -1 });
+
+    if (!transcription) {
+      console.log('No transcriptions found');
+      process.exit(0);
+    }
+
+    console.log(`Found transcription: ${transcription.conversation_id}`);
+
+    let summary = await Summary.findOne({ transcription_id: transcription._id });
+
+    if (!summary) {
+      console.log('Generating new summary...');
+      const aiService = createAIService();
+      const metadata = transcription.metadata as Record<string, unknown> | undefined;
+      const result = await aiService.generateSummary(
+        transcription.transcript,
+        { language: (metadata?.main_language as string) || 'tr' }
+      );
+
+      summary = new Summary({
+        transcription_id: transcription._id,
+        conversation_id: transcription.conversation_id,
+        summary_text: result.summary,
+        ai_provider: aiService.providerName,
+        ai_model: result.model,
+        token_usage: result.tokenUsage,
+        language: 'tr',
+        notification_status: 'pending'
+      });
+      await summary.save();
+      console.log('Summary created');
+    } else {
+      console.log('Using existing summary');
+    }
+
+    console.log('\nSummary text:');
+    console.log('---');
+    console.log(summary.summary_text);
+    console.log('---\n');
+
+    console.log('Sending WhatsApp notification...');
+    const results = await whatsappService.sendSummaryToRecipients(summary, transcription);
+
+    console.log('Results:', JSON.stringify(results, null, 2));
+
+    await mongoose.disconnect();
+    process.exit(0);
+  } catch (error) {
+    const err = error as Error;
+    console.error('Error:', err.message);
+    console.error(err.stack);
+    process.exit(1);
+  }
+}
+
+retrigger();