elevenlabs-webhook-nodejs 1.0.0

package/src/services/inbound-call-schedule.service.ts

@@ -0,0 +1,174 @@
+import InboundCallConfig, { IInboundCallConfig } from '../modules/inbound-call/inbound-call-config.model';
+import elevenlabsService from './elevenlabs.service';
+import cron from 'node-cron';
+import logger from '../utils/logger';
+
+const TIMEZONE = 'Europe/Istanbul';
+
+class InboundCallScheduleService {
+  private cronTask: ReturnType<typeof cron.schedule> | null = null;
+
+  initialize(): void {
+    // Run once on startup
+    this.syncAllSchedules().catch(err =>
+      logger.error('Initial inbound call schedule sync failed', { error: (err as Error).message }),
+    );
+
+    // Every 15 minutes at clock boundaries (:00, :15, :30, :45)
+    this.cronTask = cron.schedule('*/15 * * * *', () => {
+      this.syncAllSchedules().catch(err =>
+        logger.error('Inbound call schedule sync failed', { error: (err as Error).message }),
+      );
+    });
+
+    logger.info('Inbound call schedule service initialized');
+  }
+
+  async syncAllSchedules(): Promise<void> {
+    const configs = await InboundCallConfig.find({ schedule_enabled: true });
+    if (configs.length === 0) return;
+
+    logger.info('Syncing inbound call schedules', { count: configs.length });
+
+    for (const config of configs) {
+      try {
+        await this.syncOne(config);
+      } catch (err) {
+        logger.error('Failed to sync inbound call config', {
+          configId: config._id,
+          phoneNumberId: config.elevenlabs_phone_number_id,
+          error: (err as Error).message,
+        });
+      }
+    }
+  }
+
+  async syncConfig(configId: string): Promise<void> {
+    const config = await InboundCallConfig.findById(configId);
+    if (!config) return;
+    await this.syncOne(config);
+  }
+
+  private async syncOne(config: IInboundCallConfig): Promise<void> {
+    // Sync agent/phone/label from ElevenLabs in case it changed on their dashboard
+    try {
+      const elPhone = await elevenlabsService.getPhoneNumber(config.elevenlabs_phone_number_id);
+      let dirty = false;
+
+      const currentElAgentId = elPhone.assignedAgent?.agentId || '';
+      if (config.elevenlabs_agent_id !== currentElAgentId && currentElAgentId) {
+        logger.info('Agent changed on ElevenLabs, updating local config', {
+          phoneNumberId: config.elevenlabs_phone_number_id,
+          oldAgentId: config.elevenlabs_agent_id,
+          newAgentId: currentElAgentId,
+        });
+        config.elevenlabs_agent_id = currentElAgentId;
+        dirty = true;
+      }
+      if (config.phone_number !== elPhone.phoneNumber) {
+        config.phone_number = elPhone.phoneNumber;
+        dirty = true;
+      }
+      if (config.label !== (elPhone.label || '')) {
+        config.label = elPhone.label || '';
+        dirty = true;
+      }
+      // Update agent_assigned to reflect actual EL state
+      const actuallyAssigned = !!elPhone.assignedAgent;
+      if (config.agent_assigned !== actuallyAssigned) {
+        config.agent_assigned = actuallyAssigned;
+        dirty = true;
+      }
+      if (dirty) await config.save();
+    } catch (err) {
+      logger.error('Failed to fetch phone number from ElevenLabs', {
+        phoneNumberId: config.elevenlabs_phone_number_id,
+        error: (err as Error).message,
+      });
+    }
+
+    // Schedule = hours when agent should NOT answer (clinic hours / blocked times)
+    // Agent is active OUTSIDE the schedule
+    const withinSchedule = this.isWithinSchedule(config.schedule);
+    const shouldBeActive = !withinSchedule;
+
+    logger.info('Schedule evaluation', {
+      phoneNumberId: config.elevenlabs_phone_number_id,
+      withinBlockedHours: withinSchedule,
+      shouldBeActive,
+      currentlyAssigned: config.agent_assigned,
+      agentId: config.elevenlabs_agent_id,
+    });
+
+    if (shouldBeActive && !config.agent_assigned) {
+      // Assign agent
+      await elevenlabsService.updatePhoneNumber(config.elevenlabs_phone_number_id, {
+        agentId: config.elevenlabs_agent_id,
+      });
+      config.agent_assigned = true;
+      await config.save();
+      logger.info('Assigned agent to phone number', {
+        phoneNumberId: config.elevenlabs_phone_number_id,
+        agentId: config.elevenlabs_agent_id,
+      });
+    } else if (!shouldBeActive && config.agent_assigned) {
+      // Unassign agent
+      await elevenlabsService.updatePhoneNumber(config.elevenlabs_phone_number_id, { agentId: '' });
+      config.agent_assigned = false;
+      await config.save();
+      logger.info('Unassigned agent from phone number', {
+        phoneNumberId: config.elevenlabs_phone_number_id,
+      });
+    }
+  }
+
+  private isWithinSchedule(schedule: { day: number; start: string; end: string }[]): boolean {
+    if (!schedule || schedule.length === 0) return false;
+
+    const now = new Date();
+    const formatter = new Intl.DateTimeFormat('en-US', {
+      timeZone: TIMEZONE,
+      hour: '2-digit',
+      minute: '2-digit',
+      hour12: false,
+      weekday: 'short',
+    });
+
+    const parts = formatter.formatToParts(now);
+    const hour = parseInt(parts.find(p => p.type === 'hour')?.value || '0', 10);
+    const minute = parseInt(parts.find(p => p.type === 'minute')?.value || '0', 10);
+    const currentMinutes = hour * 60 + minute;
+
+    // Get day of week in Europe/Istanbul
+    const dayFormatter = new Intl.DateTimeFormat('en-US', { timeZone: TIMEZONE, weekday: 'short' });
+    const dayStr = dayFormatter.format(now);
+    const dayMap: Record<string, number> = { Sun: 0, Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6 };
+    const currentDay = dayMap[dayStr] ?? now.getDay();
+
+    const entry = schedule.find(e => e.day === currentDay);
+    if (!entry) return false;
+
+    const [startH, startM] = entry.start.split(':').map(Number);
+    const [endH, endM] = entry.end.split(':').map(Number);
+    const startMinutes = startH * 60 + startM;
+    const endMinutes = endH * 60 + endM;
+
+    if (startMinutes <= endMinutes) {
+      // Normal range: e.g. 09:00-18:00
+      return currentMinutes >= startMinutes && currentMinutes < endMinutes;
+    } else {
+      // Overnight range: e.g. 22:00-06:00
+      return currentMinutes >= startMinutes || currentMinutes < endMinutes;
+    }
+  }
+
+  shutdown(): void {
+    if (this.cronTask) {
+      this.cronTask.stop();
+      this.cronTask = null;
+    }
+  }
+}
+
+const inboundCallScheduleService = new InboundCallScheduleService();
+export default inboundCallScheduleService;

package/src/services/netgsm.service.ts

@@ -0,0 +1,128 @@
+import config from '../config';
+import logger from '../utils/logger';
+
+interface SendSmsResult {
+  success: boolean;
+  jobId?: string;
+  error?: string;
+  code?: string;
+}
+
+class NetGsmService {
+  private get isConfigured(): boolean {
+    return !!(config.netgsm.username && config.netgsm.password && config.netgsm.msgheader);
+  }
+
+  /**
+   * Send SMS to one or more phone numbers.
+   */
+  async sendSms(phoneNumbers: string[], message: string): Promise<SendSmsResult> {
+    if (!this.isConfigured) {
+      return { success: false, error: 'NetGSM credentials not configured' };
+    }
+
+    try {
+      const messages = phoneNumbers.map(phone => ({
+        msg: message,
+        no: phone.replace(/[^0-9]/g, ''),
+      }));
+
+      const body = {
+        msgheader: config.netgsm.msgheader,
+        messages,
+        encoding: 'TR',
+        iysfilter: '0',
+      };
+
+      const res = await fetch(config.netgsm.apiUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Basic ${Buffer.from(`${config.netgsm.username}:${config.netgsm.password}`).toString('base64')}`,
+        },
+        body: JSON.stringify(body),
+      });
+
+      const data = await res.json() as { code?: string; jobid?: string; description?: string };
+
+      if (res.ok && data.code === '00') {
+        logger.info('SMS sent via NetGSM', {
+          recipients: phoneNumbers.length,
+          jobId: data.jobid,
+        });
+        return { success: true, jobId: data.jobid, code: data.code };
+      }
+
+      logger.warn('NetGSM SMS failed', { code: data.code, description: data.description });
+      return { success: false, error: data.description || 'Unknown error', code: data.code };
+    } catch (err) {
+      logger.error('NetGSM SMS exception', { error: (err as Error).message });
+      return { success: false, error: (err as Error).message };
+    }
+  }
+
+  // ─── Appointment Notification Helpers ─────────────────────
+
+  async notifyAppointmentCreated(params: {
+    phones: string[];
+    patientName: string;
+    patientPhone: string;
+    date: string;
+    time: string;
+    notes: string;
+    detailUrl?: string;
+  }): Promise<SendSmsResult> {
+    const msg = [
+      `Yeni Randevu - Asistan 7/24`,
+      `Hasta: ${params.patientName}`,
+      `Tel: ${params.patientPhone}`,
+      `Tarih: ${params.date}`,
+      `Saat: ${params.time}`,
+      ...(params.notes ? [`Not: ${params.notes}`] : []),
+      ...(params.detailUrl ? [`Detay: ${params.detailUrl}`] : []),
+    ].join('\n');
+
+    return this.sendSms(params.phones, msg);
+  }
+
+  async notifyAppointmentCancelled(params: {
+    phones: string[];
+    patientName: string;
+    patientPhone: string;
+    date: string;
+    time: string;
+  }): Promise<SendSmsResult> {
+    const msg = [
+      `Randevu Iptal - Asistan 7/24`,
+      `Hasta: ${params.patientName}`,
+      `Tel: ${params.patientPhone}`,
+      `Iptal Edilen: ${params.date} ${params.time}`,
+    ].join('\n');
+
+    return this.sendSms(params.phones, msg);
+  }
+
+  async notifyAppointmentRescheduled(params: {
+    phones: string[];
+    patientName: string;
+    patientPhone: string;
+    oldDate: string;
+    oldTime: string;
+    newDate: string;
+    newTime: string;
+    detailUrl?: string;
+  }): Promise<SendSmsResult> {
+    const msg = [
+      `Randevu Degisikligi - Asistan 7/24`,
+      `Hasta: ${params.patientName}`,
+      `Tel: ${params.patientPhone}`,
+      `Eski: ${params.oldDate} ${params.oldTime}`,
+      `Yeni: ${params.newDate} ${params.newTime}`,
+      ...(params.detailUrl ? [`Detay: ${params.detailUrl}`] : []),
+    ].join('\n');
+
+    return this.sendSms(params.phones, msg);
+  }
+}
+
+export default new NetGsmService();

package/src/services/unipile.service.ts

@@ -0,0 +1,200 @@
+import config from '../config';
+import logger from '../utils/logger';
+
+interface ProviderConfig {
+  baseUrl: string;
+  apiKey: string;
+  webhookSecret: string;
+  isReady: boolean;
+}
+
+class UnipileService {
+  private providers: Record<string, ProviderConfig> = {};
+  public isReady: boolean = false;
+
+  async initialize(): Promise<void> {
+    // Initialize Unipile provider
+    if (config.unipile.apiKey && config.unipile.dsn) {
+      this.providers['unipile'] = {
+        baseUrl: config.unipile.dsn.replace(/\/$/, ''),
+        apiKey: config.unipile.apiKey,
+        webhookSecret: config.unipile.webhookSecret,
+        isReady: true,
+      };
+      logger.info('Unipile provider initialized', { dsn: config.unipile.dsn });
+    }
+
+    // Initialize Baileys provider
+    if (config.baileys.apiKey && config.baileys.dsn) {
+      this.providers['baileys'] = {
+        baseUrl: config.baileys.dsn.replace(/\/$/, ''),
+        apiKey: config.baileys.apiKey,
+        webhookSecret: config.baileys.webhookSecret,
+        isReady: true,
+      };
+      logger.info('Baileys provider initialized', { dsn: config.baileys.dsn });
+    }
+
+    this.isReady = Object.values(this.providers).some(p => p.isReady);
+
+    if (!this.isReady) {
+      logger.warn('No WhatsApp bridge provider configured, skipping initialization');
+    }
+  }
+
+  // ─── Provider Helpers ─────────────────────────────────────
+
+  getProviderForTenant(tenant: { settings?: { whatsapp_agent?: { whatsapp_bridge_provider?: string } } } | null): string {
+    return tenant?.settings?.whatsapp_agent?.whatsapp_bridge_provider || 'unipile';
+  }
+
+  isProviderReady(provider: string): boolean {
+    return !!this.providers[provider]?.isReady;
+  }
+
+  getAvailableProviders(): string[] {
+    return Object.entries(this.providers)
+      .filter(([, cfg]) => cfg.isReady)
+      .map(([name]) => name);
+  }
+
+  getWebhookSecret(provider: string): string {
+    return this.providers[provider]?.webhookSecret || '';
+  }
+
+  // ─── Internal Request ─────────────────────────────────────
+
+  private async request<T = unknown>(provider: string, method: string, path: string, body?: unknown): Promise<T> {
+    const cfg = this.providers[provider];
+    if (!cfg?.isReady) {
+      throw new Error(`WhatsApp bridge provider "${provider}" not configured`);
+    }
+
+    const url = `${cfg.baseUrl}/api/v1${path}`;
+
+    const headers: Record<string, string> = {
+      'X-API-KEY': cfg.apiKey,
+      'Accept': 'application/json',
+    };
+
+    const options: RequestInit = { method, headers };
+
+    if (body) {
+      headers['Content-Type'] = 'application/json';
+      options.body = JSON.stringify(body);
+    }
+
+    const res = await fetch(url, options);
+    const text = await res.text();
+
+    if (!res.ok) {
+      logger.error('Bridge request failed', { provider, method, path, status: res.status, body: text });
+      throw new Error(`${provider} ${method} ${path} failed: ${res.status} ${text}`);
+    }
+
+    try {
+      return JSON.parse(text) as T;
+    } catch {
+      return text as unknown as T;
+    }
+  }
+
+  // ─── Account Management ────────────────────────────────────
+
+  async connectWhatsApp(provider: string = 'unipile'): Promise<Record<string, unknown>> {
+    const result = await this.request<Record<string, unknown>>(
+      provider, 'POST', '/accounts', { provider: 'WHATSAPP' }
+    );
+    logger.info('connectWhatsApp full response', { provider, result: JSON.stringify(result) });
+    return result;
+  }
+
+  async reconnectAccount(provider: string = 'unipile', accountId: string): Promise<Record<string, unknown>> {
+    const result = await this.request<Record<string, unknown>>(
+      provider, 'POST', `/accounts/${accountId}/reconnect`, { provider: 'WHATSAPP' }
+    );
+    logger.info('reconnect response', { provider, accountId, result: JSON.stringify(result) });
+    return result;
+  }
+
+  async getAccountStatus(provider: string = 'unipile', accountId: string): Promise<Record<string, unknown>> {
+    const result = await this.request<Record<string, unknown>>(provider, 'GET', `/accounts/${accountId}`);
+    logger.info('Fetched account status', { provider, accountId, result: JSON.stringify(result).substring(0, 500) });
+    return result;
+  }
+
+  async disconnectAccount(provider: string = 'unipile', accountId: string): Promise<void> {
+    await this.request(provider, 'DELETE', `/accounts/${accountId}`);
+    logger.info('Disconnected account', { provider, accountId });
+  }
+
+  // ─── Messaging ─────────────────────────────────────────────
+
+  async sendMessage(provider: string = 'unipile', chatId: string, text: string): Promise<{ message_id?: string }> {
+    const result = await this.request<{ message_id?: string }>(
+      provider, 'POST', `/chats/${chatId}/messages`, { text }
+    );
+    logger.info('Sent message via bridge', { provider, chatId });
+    return result;
+  }
+
+  async forwardMedia(provider: string, chatId: string, messageId: string, toPhone: string, caption: string): Promise<void> {
+    await this.request(
+      provider, 'POST', `/chats/${chatId}/forward-media`, { message_id: messageId, to_phone: toPhone, caption }
+    );
+    logger.info('Forwarded media via bridge', { provider, chatId, toPhone });
+  }
+
+  async downloadAudio(provider: string, chatId: string, messageId: string): Promise<{ audio_base64: string; mimetype: string }> {
+    const result = await this.request<{ audio_base64: string; mimetype: string }>(
+      provider, 'GET', `/chats/${chatId}/download-audio/${messageId}`
+    );
+    logger.info('Downloaded audio via bridge', { provider, chatId, messageId });
+    return result;
+  }
+
+  async sendImage(provider: string, chatId: string, imageBase64: string, caption: string): Promise<void> {
+    await this.request(
+      provider, 'POST', `/chats/${chatId}/send-image`, { image_base64: imageBase64, caption }
+    );
+    logger.info('Sent image via bridge', { provider, chatId });
+  }
+
+  async startChat(provider: string = 'unipile', accountId: string, attendeeId: string, text: string): Promise<{ chat_id: string }> {
+    const result = await this.request<{ chat_id: string }>(
+      provider, 'POST', '/chats', {
+        account_id: accountId,
+        attendees_ids: [attendeeId],
+        text,
+      }
+    );
+    logger.info('Started new chat via bridge', { provider, accountId, attendeeId });
+    return result;
+  }
+
+  // ─── Webhooks ──────────────────────────────────────────────
+
+  async createWebhook(provider: string = 'unipile', requestUrl: string): Promise<{ id: string }> {
+    const cfg = this.providers[provider];
+    const result = await this.request<{ id: string }>(
+      provider, 'POST', '/webhooks', {
+        request_url: requestUrl,
+        source: 'messaging',
+        headers: [
+          { key: 'x-unipile-secret', value: cfg?.webhookSecret || '' },
+        ],
+      }
+    );
+    logger.info('Created webhook', { provider, id: result.id, url: requestUrl });
+    return result;
+  }
+
+  // ─── Status ────────────────────────────────────────────────
+
+  getStatus(): { isReady: boolean; providers: string[] } {
+    return { isReady: this.isReady, providers: this.getAvailableProviders() };
+  }
+}
+
+const unipileService = new UnipileService();
+export default unipileService;