@tiledesk/tiledesk-voice-twilio-connector 0.1.27 → 0.2.0-rc3

package/src/middlewares/httpLogger.js

@@ -0,0 +1,31 @@
+const logger = require('../utils/logger');
+
+let lastRequestTime = Date.now();
+
+const httpLogger = (req, res, next) => {
+  const startTime = Date.now();
+  const timeSinceLastRequest = startTime - lastRequestTime;
+  lastRequestTime = startTime;
+
+  // Hook into response finish to calculate processing time
+  res.on('finish', () => {
+    const duration = Date.now() - startTime;
+    const bodySize = req.headers['content-length'] || (req.body ? JSON.stringify(req.body).length : 0);
+
+    const logData = {
+      method: req.method,
+      path: req.path,
+      query: req.query,
+      bodySize: bodySize,
+      statusCode: res.statusCode,
+      durationMs: duration,
+      timeSinceLastRequestMs: timeSinceLastRequest
+    };
+
+    logger.info(`HTTP: ${JSON.stringify(logData)}`);
+  });
+
+  next();
+};
+
+module.exports = httpLogger;

package/src/models/KeyValueStore.js

@@ -0,0 +1,78 @@
+const mongodb = require("mongodb");
+var winston = require('../utils/logger');
+
+class KVBaseMongo {
+
+  /**
+   * Constructor for KVBaseMongo object
+   *
+   * @example
+   * const { KVBaseMongo } = require('./KVBaseMongo');
+   * let db = new KVBaseMongo("kvstore");
+   * 
+   * @param {KVBASE_COLLECTION} The name of the Mongodb collection used as key-value store. Mandatory.
+   */
+  constructor(KVBASE_COLLECTION) {
+    if (!KVBASE_COLLECTION) {
+      throw new Error('KVBASE_COLLECTION (the name of the Mongodb collection used as key-value store) is mandatory.');
+    }
+    this.KV_COLLECTION = KVBASE_COLLECTION;
+    winston.debug("KV_COLLECTION: " + this.KV_COLLECTION)
+  }
+
+  async connect(MONGODB_URI) {
+    try {
+      const client = await mongodb.MongoClient.connect(MONGODB_URI, { useNewUrlParser: true, useUnifiedTopology: true });
+      this.db = client.db();
+      await this.db.collection(this.KV_COLLECTION).createIndex(
+        { "key": 1 }, { unique: true }
+      );
+      //winston.debug("[mongodb] db: ", this.db);
+    } catch (err) {
+      winston.error(err);
+      process.exit(1);
+    }
+  }
+
+  async set(k, v) {
+    try {
+      await this.db.collection(this.KV_COLLECTION).updateOne({key: k}, { $set: { value: v, key: k } }, { upsert: true });
+    } catch (err) {
+      throw err;
+    }
+  }
+  
+  async reuseConnection(db) {
+    this.db = db;
+    await this.db.collection(this.KV_COLLECTION).createIndex(
+      { "key": 1 }, { unique: true }
+    );
+  }
+
+  async get(k) {
+    winston.debug("Searching on Collection " + this.KV_COLLECTION + ' for key: '+ k);
+    try {
+      const doc = await this.db.collection(this.KV_COLLECTION).findOne({ key: k });
+      if (doc) {
+        winston.debug("Doc found with key: " + doc.key);
+        return doc.value;
+      } else {
+        winston.debug("No Doc found!");
+        return null;
+      }
+    } catch (err) {
+      winston.error("Error reading mongodb value", err);
+      throw err;
+    }
+  }
+
+  async remove(k) {
+    try {
+      await this.db.collection(this.KV_COLLECTION).deleteOne({key: k});
+    } catch (err) {
+      throw err;
+    }
+  }
+}
+
+module.exports = { KVBaseMongo };

package/src/routes/manageApp.js

@@ -0,0 +1,298 @@
+"use strict";
+const express = require("express");
+const bodyParser = require("body-parser")
+const router = express.Router();
+const winston = require("../utils/logger");
+const pjson = require('../../package.json');
+const fs = require('fs').promises;
+const path = require('path');
+const handlebars = require('handlebars');
+
+// tiledesk clients
+const { TiledeskChannel } = require("../services/channels/TiledeskChannel")
+const { TiledeskSubscriptionClient } = require('../services/clients/TiledeskSubscriptionClient');
+
+//constant 
+const CHANNEL_NAME = require('../utils/constants').CHANNEL_NAME;
+
+router.use(bodyParser.json());
+router.use(express.urlencoded({ extended: true }));
+router.use(express.static(path.join(__dirname, '..', 'template')));
+
+// Handlebars helpers
+handlebars.registerHelper('isEqual', (a, b) => a == b);
+handlebars.registerHelper('json', (a) => JSON.stringify(a));
+
+module.exports = (services) => {
+  const { db, redisClient, config } = services;
+  const API_URL = config.API_URL;
+  const BASE_URL = config.BASE_URL;
+  const BRAND_NAME = config.BRAND_NAME || "Tiledesk";
+
+  // Helper to render template
+  async function renderTemplate(templateName, data) {
+    const templatePath = path.join(__dirname, '..', 'template', templateName);
+    try {
+      const html = await fs.readFile(templatePath, 'utf-8');
+      const template = handlebars.compile(html);
+      return template(data);
+    } catch (err) {
+      winston.error("Error rendering template:", err);
+      throw err;
+    }
+  }
+
+  router.get("/", async (req, res) => {
+    res.send("Welcome to Tiledesk-VOICE connector (manage ROUTE)");
+  });
+
+  router.get('/configure', async (req, res) => {
+    winston.debug("(voice) /configure :params", req.query);
+    
+    let project_id = req.query.project_id;
+    let token = req.query.token;
+    let popup_view = req.query.view === 'popup';
+
+    if (!project_id || !token) {
+      const html = await renderTemplate('error.html', {
+        app_version: pjson.version,
+        error_message: "Query params project_id and token are required."
+      });
+      return res.send(html);
+    }
+
+    try {
+      let CONTENT_KEY = CHANNEL_NAME + "-" + project_id;
+      let settings = await db.get(CONTENT_KEY);
+      winston.debug("(voice) settings: ", settings);
+      
+      const tdChannel = new TiledeskChannel({
+        API_URL: API_URL,
+        redis_client: redisClient
+      })
+      
+      let departments = await tdChannel.getDepartments(token, project_id).catch((err) => {
+        winston.error("Error getting departments", err.response);
+        return [];
+      });
+      
+      let proxy_url = BASE_URL + "/webhook/" + project_id;
+      let status_url = BASE_URL + "/twilio/status";
+
+      if (!settings) {
+        try {
+            const subscription = await subscribe(token, project_id, API_URL, BASE_URL, db);
+            settings = {
+                project_id: project_id,
+                token: token,
+                subscriptionId: subscription._id,
+                secret: subscription.secret
+            };
+        } catch(e) {
+            winston.error("Auto-subscribe failed", e);
+            const html = await renderTemplate('error.html', {
+                app_version: pjson.version,
+                error_message: "Auto-subscribe failed: " + e.message
+            });
+            return res.send(html);
+        }
+      }
+
+      const html = await renderTemplate('configure.html', {
+        app_version: pjson.version,
+        project_id: project_id,
+        token: token,
+        proxy_url: proxy_url,
+        status_url: status_url,
+        subscription_id: settings.subscriptionId,
+        department_id: settings.department_id,
+        account_sid: settings.account_sid,
+        auth_token: settings.auth_token,
+        departments: departments,
+        brand_name: BRAND_NAME,
+        popup_view: popup_view
+      });
+      
+      return res.send(html);
+
+    } catch (err) {
+      winston.error("Error in /configure", err);
+      const html = await renderTemplate('error.html', {
+        app_version: pjson.version,
+        error_message: "Internal Server Error: " + err.message
+      });
+      return res.status(500).send(html);
+    }
+  })
+
+  router.post('/update', async (req, res) => {
+    winston.debug("(voice) /update", req.body);
+
+    let project_id = req.body.project_id;
+    let token = req.body.token;
+    let department_id = req.body.department;
+    let account_sid = req.body.account_sid;
+    let auth_token = req.body.auth_token;
+
+    if (!project_id || !token) {
+        return res.status(400).send("project_id and token are required");
+    }
+
+    let CONTENT_KEY = CHANNEL_NAME + "-" + project_id;
+    let settings = await db.get(CONTENT_KEY);
+    
+    let proxy_url = BASE_URL + "/webhook/" + project_id;
+    let status_url = BASE_URL + "/twilio/status";
+
+    // get departments
+    const tdChannel = new TiledeskChannel({
+        API_URL: API_URL,
+        redis_client: redisClient
+    })
+    
+    let departments = await tdChannel.getDepartments(token, project_id).catch((err) => {
+        winston.error("Error getting departments", err.response);
+        return [];
+    });
+
+    try {
+        if (settings) {
+            settings.department_id = department_id;
+            settings.account_sid = account_sid;
+            settings.auth_token = auth_token;
+            await db.set(CONTENT_KEY, settings);
+        } else {
+            const subscription = await subscribe(token, project_id, API_URL, BASE_URL, db);
+            settings = {
+                project_id: project_id,
+                token: token,
+                subscriptionId: subscription._id,
+                secret: subscription.secret,
+                department_id: department_id,
+                account_sid: account_sid,
+                auth_token: auth_token
+            };
+            await db.set(CONTENT_KEY, settings);
+        }
+
+        const html = await renderTemplate('configure.html', {
+            app_version: pjson.version,
+            project_id: project_id,
+            token: token,
+            proxy_url: proxy_url,
+            status_url: status_url,
+            show_success_modal: true,
+            subscription_id: settings.subscriptionId,
+            department_id: settings.department_id,
+            account_sid: settings.account_sid,
+            auth_token: settings.auth_token,
+            departments: departments,
+            brand_name: BRAND_NAME
+        });
+        return res.send(html);
+
+    } catch (error) {
+        winston.error("Update failed", error);
+        const html = await renderTemplate('configure.html', {
+            app_version: pjson.version,
+            project_id: project_id,
+            token: token,
+            proxy_url: proxy_url,
+            status_url: status_url,
+            show_error_modal: true,
+            departments: departments,
+            brand_name: BRAND_NAME
+        });
+        return res.send(html);
+    }
+  })
+
+  router.post('/disconnect', async (req, res) => {
+    winston.debug("(voice) /disconnect")
+
+    let project_id = req.body.project_id;
+    let token = req.body.token;
+    let subscriptionId = req.body.subscription_id;
+
+    if (!project_id || !token) {
+        return res.status(400).send("project_id and token are required");
+    }
+
+    let CONTENT_KEY = CHANNEL_NAME + "-" + project_id;
+    await db.remove(CONTENT_KEY);
+    winston.debug("(voice) Content deleted.");
+
+    let proxy_url = BASE_URL + "/webhook/" + project_id;
+    let status_url = BASE_URL + "/twilio/status";
+
+    // get departments
+    const tdChannel = new TiledeskChannel({
+        API_URL: API_URL,
+        redis_client: redisClient
+    })
+    
+    let departments = await tdChannel.getDepartments(token, project_id).catch((err) => {
+        winston.error("Error getting departments", err.response);
+        return [];
+    });
+
+    try {
+        if (subscriptionId) {
+            await unsubscribe(token, project_id, subscriptionId, API_URL);
+        }
+    } catch (err) {
+        winston.error("(voice) unsubscribe error: " + err);
+    }
+
+    const html = await renderTemplate('configure.html', {
+        app_version: pjson.version,
+        project_id: project_id,
+        token: token,
+        proxy_url: proxy_url,
+        status_url: status_url,
+        departments: departments,
+        brand_name: BRAND_NAME
+    });
+    return res.send(html);
+  })
+
+  return router;
+};
+
+async function subscribe(token, project_id, API_URL, BASE_URL, db){
+  const tdClient = new TiledeskSubscriptionClient({ API_URL: API_URL, project_id: project_id, token: token })
+  
+  const CONTENT_KEY = CHANNEL_NAME + "-" + project_id;
+  const subscription_info = {
+    target: BASE_URL + "/tiledesk",
+    event: 'message.create.request.channel.'+ CHANNEL_NAME
+  }
+  
+  try {
+    const subscription = await tdClient.subscribe(subscription_info);
+    winston.debug("(voice) Subscription: ", subscription)
+
+    let settings = {
+        project_id: project_id,
+        token: token,
+        subscriptionId: subscription._id,
+        secret: subscription.secret
+    }
+
+    await db.set(CONTENT_KEY, settings);
+    return subscription;
+  } catch (error) {
+    throw error;
+  }
+}
+
+async function unsubscribe(token, project_id, subscriptionId, API_URL){
+  const tdClient = new TiledeskSubscriptionClient({ API_URL: API_URL, project_id: project_id, token: token })
+  try {
+    const data = await tdClient.unsubscribe(subscriptionId);
+    winston.debug("(voice) Subscription: ", data)
+    return data;
+  } catch (error) {
+    throw error;
+  }
+}

package/src/routes/voice.js

@@ -0,0 +1,22 @@
+const express = require('express');
+const router = express.Router();
+const VoiceController = require('../controllers/VoiceController');
+
+module.exports = (services) => {
+  const voiceController = new VoiceController(services);
+
+  router.get('/', (req, res) => voiceController.index(req, res));
+  router.post('/tiledesk', (req, res) => voiceController.tiledesk(req, res));
+  router.post('/webhook/:id_project', (req, res) => voiceController.webhook(req, res));
+  router.post('/nextblock/:callSid', (req, res) => voiceController.nextblock(req, res));
+  router.post('/speechresult/:callSid', (req, res) => voiceController.speechresult(req, res));
+  router.post('/record/action/:callSid', (req, res) => voiceController.recordAction(req, res));
+  router.post('/record/callback/:callSid', (req, res) => voiceController.recordCallback(req, res));
+  router.post('/menublock/:callSid', (req, res) => voiceController.menublock(req, res));
+  router.post('/handle/:callSid/:event', (req, res) => voiceController.handleEvent(req, res));
+  router.post('/event/:callSid/:event', (req, res) => voiceController.event(req, res));
+  router.post('/twilio/status', (req, res) => voiceController.twilioStatus(req, res));
+  router.post('/twilio/fail', (req, res) => voiceController.twilioFail(req, res));
+  
+  return router;
+};

package/src/services/AiService.js

@@ -0,0 +1,219 @@
+var winston = require('../utils/logger');
+const axios = require("axios").default;
+const FormData = require('form-data');
+
+/*ERROR HANDLER*/
+const { ServiceError } = require('../utils/errors');
+
+/*UTILS*/
+const fileUtils = require('../utils/fileUtils.js')
+
+class AiService {
+  
+  constructor(config) {
+    
+    if (!config) {
+      throw new Error("[AiService] config is mandatory");
+    }
+    if (!config.OPENAI_ENDPOINT) {
+      throw new Error("[AiService] config.OPENAI_ENDPOINT is mandatory");
+    }
+    if(!config.ELEVENLABS_ENDPOINT){
+      throw new Error("[AiService] config.ELEVENLABS_ENDPOINT is mandatory");
+    }
+    if (!config.API_URL) {
+      throw new Error("[AiService] config.API_URL is mandatory");
+    }
+    
+
+    this.OPENAI_ENDPOINT = config.OPENAI_ENDPOINT;
+    this.ELEVENLABS_ENDPOINT = config.ELEVENLABS_ENDPOINT;
+    this.API_URL = config.API_URL;
+        
+  }
+  
+  async speechToText(fileUrl, model, GPT_KEY) {
+    let start_time = new Date(); 
+    winston.debug("[AiService] speechToText url: "+ fileUrl);   
+    
+    try {
+      let file;
+      try {
+        file = await fileUtils.downloadFromUrl(fileUrl);
+      } catch (err) {
+        winston.error("[AiService] err while downloadFromUrl: ", err);
+        throw new ServiceError('AISERVICE_FAILED', 'Cannot download audio file:', fileUrl);
+      }
+      
+      if (!file) {
+        winston.debug('[AiService] OPENAI speechToText file NOT EXIST: . . . return');
+        throw new ServiceError('AISERVICE_FAILED', 'Cannot download audio file: file is null');
+      }
+
+      const formData = new FormData();
+      formData.append('file', file, { filename: 'audiofile.wav', contentType: 'audio/wav' });
+      formData.append('model', model);
+
+      const resbody = await axios({
+        url: `${this.OPENAI_ENDPOINT}/audio/transcriptions`,
+        headers: {
+          ...formData.getHeaders(),
+          "Authorization": "Bearer " + GPT_KEY
+        },
+        data: formData,
+        method: 'POST'
+      });
+
+      let end_time = new Date();
+      winston.verbose(`-----> [AiService] OpenAI speechToText time elapsed: ${end_time - start_time} ms`);
+      return resbody.data.text;
+
+    } catch (err) {
+      if (err instanceof ServiceError) throw err;
+      winston.error("[AiService] OpenAI STT error", err.message);
+      throw new ServiceError('AISERVICE_FAILED', 'OpenAI STT service failed with err:', err);
+    }
+  }
+  
+  async textToSpeech(text, name, model, GPT_KEY){
+    let start_time = new Date();
+    winston.debug('[AiService] textToSpeech text:'+ text)
+    
+    const data = {
+      model: model,
+      input: text,
+      voice: name,
+    };
+    
+    winston.debug('[AiService] textToSpeech config:', data)
+    
+    try {
+      const response = await axios({
+        url: `${this.OPENAI_ENDPOINT}/audio/speech`,
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": "Bearer " + GPT_KEY
+        },
+        responseType: 'arraybuffer',
+        data: data,
+        method: "POST",
+      });
+
+      let end_time = new Date();
+      winston.verbose(`-----> [AiService] textToSpeech time elapsed: ${end_time - start_time} ms`);          
+      return response?.data;
+    } catch (err) {
+      winston.error("[AiService] textToSpeech error: ", err.response?.data);
+      throw new ServiceError('AISERVICE_FAILED', 'OpenAI textToSpeech API failed with err:', err);
+    }
+  }
+  
+  
+  
+  async speechToTextElevenLabs(fileUrl, model, language, API_KEY) {
+    let start_time = new Date();
+    winston.debug("[AiService] ELEVEN Labs speechToText url: "+ fileUrl);   
+    
+    try {
+      let file;
+      try {
+        file = await fileUtils.downloadFromUrl(fileUrl);
+      } catch (err) {
+        winston.error("[AiService] err: ", err);
+        throw new ServiceError('AISERVICE_FAILED', 'Cannot download audio file:', fileUrl);
+      }
+      
+      if (!file) {
+        winston.debug('[AiService] ELEVEN Labs speechToText file NOT EXIST: . . . return');
+        throw new ServiceError('AISERVICE_FAILED', 'Cannot download audio file: file is null');
+      }
+    
+      const formData = new FormData();
+      formData.append('file', file, { filename: 'audiofile.wav', contentType: 'audio/wav' });
+      formData.append('model_id', "scribe_v1");
+      formData.append('language_code', language);
+
+      const resbody = await axios({
+        url: `${this.ELEVENLABS_ENDPOINT}/v1/speech-to-text`,
+        headers: {
+          ...formData.getHeaders(),
+          "xi-api-key": API_KEY
+        },
+        data: formData,
+        method: 'POST'
+      });
+
+      let end_time = new Date();
+      winston.verbose(`-----> [AiService] ELEVEN Labs speechToText time elapsed: ${end_time - start_time} ms`);
+      return resbody.data.text;
+
+    } catch (err) {
+      if (err instanceof ServiceError) throw err;
+      winston.error("[AiService] ElevenLabs STT error", err.message);
+      throw new ServiceError('AISERVICE_FAILED', 'ElevenLabs STT service failed with err:', err);
+    }
+  }
+  
+  async textToSpeechElevenLabs(text, voice_id, model, language_code, API_KEY){
+    let start_time = new Date();
+    const data = {
+      model_id: model,
+      text: text,
+      language_code: language_code
+    };
+    winston.debug('[AiService] ELEVEN Labs textToSpeech config:', data);
+    
+    try {
+      const response = await axios({
+        url: `${this.ELEVENLABS_ENDPOINT}/v1/text-to-speech/${voice_id}?output_format=mp3_44100_128`,
+        headers: {
+          "Content-Type": "application/json",
+          "xi-api-key": API_KEY
+        },
+        responseType: 'arraybuffer',
+        data: data,
+        method: "POST",
+      });
+
+      let end_time = new Date();
+      winston.verbose(`-----> [AiService] ELEVEN Labs textToSpeech time elapsed: ${end_time - start_time} ms`);            
+      return response?.data;
+    } catch (err) {
+      winston.error("[AiService] ELEVEN Labs textToSpeech error: ", err);
+      throw new ServiceError('AISERVICE_FAILED', 'ElevenLabs textToSpeech API failed with err:', err);
+    }
+  }
+  
+  
+  
+  async checkQuoteAvailability(projectId, token) {
+
+    winston.debug("[AiService] checkQuoteAvailability for project: "+ projectId);   
+          
+    try {
+      const resbody = await axios({
+        url: `${this.API_URL}/${projectId}/quotes/tokens`,
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': token
+        },
+        method: 'GET'
+      });
+
+      if (resbody && resbody.data?.isAvailable === true) {
+        return true;
+      } else {
+        return false;
+      }
+    } catch (err) {
+      winston.error("[AiService] checkQuoteAvailability error: ", err.response?.data);
+      throw new ServiceError('AISERVICE_FAILED', 'checkQuoteAvailability API failed with err:', err);
+    }
+  }
+  
+  
+  
+  
+}
+
+module.exports = { AiService };