elevenlabs-webhook-nodejs 1.0.0

package/nestjs/src/integrations/elevenlabs/elevenlabs.service.ts

@@ -0,0 +1,226 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+
+interface BatchCallConfig {
+  name: string;
+  agent_id: string;
+  phone_numbers: Array<{
+    phone_number: string;
+    dynamic_variables?: Record<string, string>;
+  }>;
+}
+
+interface SipTrunkOutboundParams {
+  agent_id: string;
+  agent_phone_number_id: string;
+  to_phone_number: string;
+  dynamic_variables?: Record<string, string>;
+}
+
+@Injectable()
+export class ElevenLabsService {
+  private readonly logger = new Logger(ElevenLabsService.name);
+  private readonly baseUrl = 'https://api.elevenlabs.io';
+  private readonly apiKey: string;
+
+  constructor(private readonly config: ConfigService) {
+    this.apiKey = this.config.get<string>('ELEVENLABS_API_KEY', '');
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  Conversational AI                                                  */
+  /* ------------------------------------------------------------------ */
+
+  /** Get a signed WebSocket URL for text-only conversational chat. */
+  async getSignedUrl(agentId: string): Promise<{ signed_url: string }> {
+    return this.request<{ signed_url: string }>(
+      'GET',
+      `/v1/convai/conversation/get-signed-url?agent_id=${agentId}`,
+    );
+  }
+
+  /** Fetch conversation details. */
+  async getConversation(conversationId: string): Promise<any> {
+    return this.request('GET', `/v1/convai/conversations/${conversationId}`);
+  }
+
+  /** Fetch conversation cost breakdown. */
+  async getConversationCost(conversationId: string): Promise<any> {
+    return this.request(
+      'GET',
+      `/v1/convai/conversations/${conversationId}/cost`,
+    );
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  Agent CRUD                                                         */
+  /* ------------------------------------------------------------------ */
+
+  /** Create a new conversational AI agent. */
+  async createAgent(params: {
+    name: string;
+    conversation_config: {
+      agent: {
+        prompt: {
+          prompt: string;
+          tools?: any[];
+        };
+        first_message?: string;
+        language?: string;
+      };
+    };
+  }): Promise<{ agent_id: string }> {
+    return this.request<{ agent_id: string }>('POST', '/v1/convai/agents/create', params);
+  }
+
+  /** Update an existing agent's configuration. */
+  async updateAgent(agentId: string, params: {
+    name?: string;
+    conversation_config?: {
+      agent?: {
+        prompt?: {
+          prompt?: string;
+          tools?: any[];
+        };
+        first_message?: string;
+        language?: string;
+      };
+    };
+  }): Promise<any> {
+    return this.request('POST', `/v1/convai/agents/${agentId}`, params);
+  }
+
+  /** Get agent details. */
+  async getAgent(agentId: string): Promise<any> {
+    return this.request('GET', `/v1/convai/agents/${agentId}`);
+  }
+
+  /** List agents (single page). Returns cursor info for pagination. */
+  async listAgents(cursor?: string): Promise<{ agents: any[]; has_more: boolean; next_cursor: string | null }> {
+    const params = new URLSearchParams();
+    if (cursor) params.set('cursor', cursor);
+
+    const qs = params.toString();
+    const page = await this.request<Record<string, any>>(
+      'GET',
+      `/v1/convai/agents${qs ? `?${qs}` : ''}`,
+    );
+
+    const agents = page.agents ?? [];
+    const hasMore = page.has_more ?? false;
+    const nextCursor = page.next_cursor ?? page.last_id ?? page.cursor ?? null;
+
+    return {
+      agents,
+      has_more: hasMore && agents.length > 0,
+      next_cursor: hasMore ? nextCursor : null,
+    };
+  }
+
+  /** Delete an agent. */
+  async deleteAgent(agentId: string): Promise<void> {
+    await this.request('DELETE', `/v1/convai/agents/${agentId}`);
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  Batch Calls                                                        */
+  /* ------------------------------------------------------------------ */
+
+  /** Submit a batch outbound call. */
+  async submitBatchCall(config: BatchCallConfig): Promise<any> {
+    return this.request('POST', '/v1/convai/batch-calling/submit', config);
+  }
+
+  /** Get batch call status. */
+  async getBatchCall(batchId: string): Promise<any> {
+    return this.request('GET', `/v1/convai/batch-calling/${batchId}`);
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  SIP Trunk                                                          */
+  /* ------------------------------------------------------------------ */
+
+  /** Initiate an outbound call via SIP trunk. */
+  async sipTrunkOutboundCall(params: SipTrunkOutboundParams): Promise<any> {
+    return this.request(
+      'POST',
+      '/v1/convai/twilio/outbound-call',
+      params,
+    );
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  Speech-to-Text (Scribe)                                            */
+  /* ------------------------------------------------------------------ */
+
+  /** Transcribe audio via ElevenLabs Scribe STT. */
+  async transcribe(
+    audioBuffer: Buffer,
+    language = 'tr',
+  ): Promise<{ text: string }> {
+    const formData = new FormData();
+    const ab = audioBuffer.buffer.slice(
+      audioBuffer.byteOffset,
+      audioBuffer.byteOffset + audioBuffer.byteLength,
+    ) as ArrayBuffer;
+    formData.append(
+      'audio',
+      new Blob([ab]),
+      'audio.wav',
+    );
+    formData.append('language_code', language);
+
+    const res = await fetch(`${this.baseUrl}/v1/speech-to-text`, {
+      method: 'POST',
+      headers: {
+        'xi-api-key': this.apiKey,
+      },
+      body: formData,
+    });
+
+    if (!res.ok) {
+      const body = await res.text();
+      this.logger.error(`Scribe transcribe failed: ${res.status} ${body}`);
+      throw new Error(`ElevenLabs transcribe failed: ${res.status}`);
+    }
+
+    return res.json() as Promise<{ text: string }>;
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  Internal HTTP helper                                               */
+  /* ------------------------------------------------------------------ */
+
+  private async request<T = any>(
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE',
+    path: string,
+    body?: unknown,
+  ): Promise<T> {
+    const url = `${this.baseUrl}${path}`;
+    const headers: Record<string, string> = {
+      'xi-api-key': this.apiKey,
+    };
+
+    const init: RequestInit = { method, headers };
+
+    if (body !== undefined) {
+      headers['Content-Type'] = 'application/json';
+      init.body = JSON.stringify(body);
+    }
+
+    const res = await fetch(url, init);
+
+    if (!res.ok) {
+      const text = await res.text();
+      this.logger.error(`ElevenLabs ${method} ${path} failed: ${res.status} ${text}`);
+      throw new Error(`ElevenLabs API error: ${res.status}`);
+    }
+
+    const contentType = res.headers.get('content-type') ?? '';
+    if (contentType.includes('application/json')) {
+      return res.json() as Promise<T>;
+    }
+
+    return (await res.text()) as unknown as T;
+  }
+}

package/nestjs/src/integrations/encryption/encryption.module.ts

@@ -0,0 +1,9 @@
+import { Global, Module } from '@nestjs/common';
+import { EncryptionService } from './encryption.service';
+
+@Global()
+@Module({
+  providers: [EncryptionService],
+  exports: [EncryptionService],
+})
+export class EncryptionModule {}

package/nestjs/src/integrations/encryption/encryption.service.ts

@@ -0,0 +1,31 @@
+import { Injectable } from '@nestjs/common';
+import { createCipheriv, createDecipheriv, randomBytes } from 'crypto';
+
+@Injectable()
+export class EncryptionService {
+  encrypt(plaintext: string, key: string): string {
+    const keyBuffer = Buffer.from(key, 'hex');
+    const iv = randomBytes(12);
+    const cipher = createCipheriv('aes-256-gcm', keyBuffer, iv);
+    const encrypted = Buffer.concat([
+      cipher.update(plaintext, 'utf8'),
+      cipher.final(),
+    ]);
+    const authTag = cipher.getAuthTag();
+    return Buffer.concat([iv, authTag, encrypted]).toString('base64');
+  }
+
+  decrypt(ciphertext: string, key: string): string {
+    const keyBuffer = Buffer.from(key, 'hex');
+    const buf = Buffer.from(ciphertext, 'base64');
+    const iv = buf.subarray(0, 12);
+    const authTag = buf.subarray(12, 28);
+    const data = buf.subarray(28);
+    const decipher = createDecipheriv('aes-256-gcm', keyBuffer, iv);
+    decipher.setAuthTag(authTag);
+    return Buffer.concat([
+      decipher.update(data),
+      decipher.final(),
+    ]).toString('utf8');
+  }
+}

package/nestjs/src/integrations/image/image.module.ts

@@ -0,0 +1,9 @@
+import { Module, Global } from '@nestjs/common';
+import { ImageService } from './image.service';
+
+@Global()
+@Module({
+  providers: [ImageService],
+  exports: [ImageService],
+})
+export class ImageModule {}

package/nestjs/src/integrations/image/image.service.ts

@@ -0,0 +1,61 @@
+import { Injectable, Logger } from '@nestjs/common';
+import sharp from 'sharp';
+
+export interface ThumbnailResult {
+  buffer: Buffer;
+  contentType: string;
+}
+
+@Injectable()
+export class ImageService {
+  private readonly logger = new Logger(ImageService.name);
+
+  /**
+   * Generate a thumbnail from an image buffer.
+   * Output is always JPEG for consistency and smaller size.
+   */
+  async generateThumbnail(
+    input: Buffer,
+    options: { width?: number; height?: number; quality?: number } = {},
+  ): Promise<ThumbnailResult> {
+    const { width = 300, height = 300, quality = 80 } = options;
+
+    const buffer = await sharp(input)
+      .resize(width, height, { fit: 'inside', withoutEnlargement: true })
+      .jpeg({ quality, mozjpeg: true })
+      .toBuffer();
+
+    return { buffer, contentType: 'image/jpeg' };
+  }
+
+  /**
+   * Resize an image to max dimensions while preserving aspect ratio.
+   * Useful for capping uploaded image size.
+   */
+  async resize(
+    input: Buffer,
+    options: { maxWidth?: number; maxHeight?: number; quality?: number } = {},
+  ): Promise<ThumbnailResult> {
+    const { maxWidth = 2000, maxHeight = 2000, quality = 85 } = options;
+
+    const buffer = await sharp(input)
+      .resize(maxWidth, maxHeight, { fit: 'inside', withoutEnlargement: true })
+      .jpeg({ quality, mozjpeg: true })
+      .toBuffer();
+
+    return { buffer, contentType: 'image/jpeg' };
+  }
+
+  /**
+   * Get image metadata (width, height, format, size).
+   */
+  async getMetadata(input: Buffer) {
+    const meta = await sharp(input).metadata();
+    return {
+      width: meta.width,
+      height: meta.height,
+      format: meta.format,
+      size: meta.size,
+    };
+  }
+}

package/nestjs/src/integrations/meta-business/meta-business.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { MetaWhatsAppService } from './meta-whatsapp.service';
+import { MetaInstagramService } from './meta-instagram.service';
+import { MetaWebhookService } from './meta-webhook.service';
+
+@Module({
+  providers: [MetaWhatsAppService, MetaInstagramService, MetaWebhookService],
+  exports: [MetaWhatsAppService, MetaInstagramService, MetaWebhookService],
+})
+export class MetaBusinessModule {}

package/nestjs/src/integrations/meta-business/meta-instagram.service.ts

@@ -0,0 +1,94 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+
+@Injectable()
+export class MetaInstagramService {
+  private readonly logger = new Logger(MetaInstagramService.name);
+  private readonly apiVersion: string;
+
+  constructor(private readonly config: ConfigService) {
+    this.apiVersion = this.config.get<string>('META_API_VERSION', 'v21.0');
+  }
+
+  /** Send a text DM via Instagram Messaging API. */
+  async sendMessage(
+    igUserId: string,
+    recipientId: string,
+    text: string,
+    accessToken: string,
+  ): Promise<any> {
+    // Try Instagram Graph API first (for Instagram Login tokens)
+    const igUrl = `https://graph.instagram.com/${this.apiVersion}/${igUserId}/messages`;
+    const igRes = await fetch(igUrl, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        recipient: { id: recipientId },
+        message: { text },
+      }),
+    });
+
+    if (igRes.ok) {
+      return igRes.json();
+    }
+
+    // Fallback: try Facebook Graph API (for Facebook Login page tokens)
+    const fbUrl = `https://graph.facebook.com/${this.apiVersion}/${igUserId}/messages`;
+    const fbRes = await fetch(fbUrl, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        recipient: { id: recipientId },
+        message: { text },
+      }),
+    });
+
+    if (!fbRes.ok) {
+      const body = await fbRes.text();
+      this.logger.error(`Instagram sendMessage failed: ${fbRes.status} ${body}`);
+      throw new Error(`Meta Instagram sendMessage failed: ${fbRes.status}`);
+    }
+
+    return fbRes.json();
+  }
+
+  /** Send media via Instagram Messaging API. */
+  async sendMedia(
+    igUserId: string,
+    recipientId: string,
+    mediaUrl: string,
+    accessToken: string,
+  ): Promise<any> {
+    const url = `https://graph.instagram.com/${this.apiVersion}/${igUserId}/messages`;
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        recipient: { id: recipientId },
+        message: {
+          attachment: {
+            type: 'image',
+            payload: { url: mediaUrl },
+          },
+        },
+      }),
+    });
+
+    if (!res.ok) {
+      const body = await res.text();
+      this.logger.error(`Instagram sendMedia failed: ${res.status} ${body}`);
+      throw new Error(`Meta Instagram sendMedia failed: ${res.status}`);
+    }
+
+    return res.json();
+  }
+}

package/nestjs/src/integrations/meta-business/meta-webhook.service.ts

@@ -0,0 +1,52 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { createHmac, timingSafeEqual } from 'crypto';
+
+@Injectable()
+export class MetaWebhookService {
+  private readonly logger = new Logger(MetaWebhookService.name);
+  private readonly appSecret: string;
+  private readonly verifyToken: string;
+
+  constructor(private readonly config: ConfigService) {
+    // Use WhatsApp secret first, fall back to Instagram
+    this.appSecret = this.config.get<string>('META_WHATSAPP_APP_SECRET', '')
+      || this.config.get<string>('META_INSTAGRAM_APP_SECRET', '');
+    this.verifyToken = this.config.get<string>('META_VERIFY_TOKEN', '');
+  }
+
+  /** Verify HMAC-SHA256 signature from X-Hub-Signature-256 header. */
+  verifySignature(signature: string, rawBody: Buffer | string): boolean {
+    if (!this.appSecret) {
+      this.logger.warn('No META app secret configured, skipping signature check');
+      return false;
+    }
+
+    const expected = createHmac('sha256', this.appSecret)
+      .update(rawBody)
+      .digest('hex');
+
+    const expectedSig = `sha256=${expected}`;
+
+    if (signature.length !== expectedSig.length) {
+      return false;
+    }
+
+    return timingSafeEqual(
+      Buffer.from(signature),
+      Buffer.from(expectedSig),
+    );
+  }
+
+  /** Verify hub.verify_token and return hub.challenge for webhook subscription. */
+  verifyChallenge(
+    verifyToken: string,
+    challenge: string,
+  ): string | null {
+    if (verifyToken === this.verifyToken) {
+      return challenge;
+    }
+    this.logger.warn('Webhook verify token mismatch');
+    return null;
+  }
+}