@tiledesk/tiledesk-tybot-connector 0.3.4 → 0.3.5-rc1

package/CHANGELOG.md

@@ -5,6 +5,10 @@
 available on:
  ▶️ https://www.npmjs.com/package/@tiledesk/tiledesk-tybot-connector
 
+# v0.3.5-rc1
+- changed: refactoring web-request-v2
+- bug-fixed: jsonBody parse error in web-request-v2
+
 # v0.3.4
 -bug-fixed: slit is undefined in TiledeskChatbotUtils
 
@@ -14,6 +18,18 @@ available on:
 # v0.3.2
 - bug-fixed: minor improvement
 
+# v0.2.153-rc9
+- changed: updated tiledesk-multi-worker to 0.2.1-rc2   
+
+# v0.2.153-rc8
+- added: fixToken function in TiledeskService utils class
+
+# v0.2.153-rc4
+- log added
+
+# v0.2.153-rc3
+- added: specchToText function to transcript audio file
+
 # v0.2.153-rc1
 - changed: context for gpt-40 and gpt-40-mini
 

package/Logger.js

@@ -0,0 +1,86 @@
+let { Publisher } = require("@tiledesk/tiledesk-multi-worker");
+
+const AMQP_MANAGER_URL = process.env.AMQP_MANAGER_URL;
+let publisher = new Publisher(AMQP_MANAGER_URL, {
+    debug: false,
+    queueName: "logs_queue",
+    exchange: "tiledesk-multi",
+    topic: "logs",
+})
+
+class Logger {
+
+    constructor(config) {
+
+        if (!config) {
+            throw new Error('config is mandatory');
+        }
+
+        if (!config.request_id) {
+            console.error('config.request_id is mandatory');
+            //throw new Error('config.request_id is mandatory');
+        }
+
+        this.request_id = config.request_id;
+        this.dev = false;
+        if (config.dev && config.dev === true) {
+            this.dev = true;
+        }
+
+        if (!AMQP_MANAGER_URL) {
+            console.error('AMQP_MANAGER_URL is undefined. Logger not available...');
+            return;
+            //throw new Error("Error starting logger: AMQP_MANAGER_URL is undefined.")
+        }
+
+    }
+
+    error(...args) {
+        let log = this.formatLog(args);
+        return this.base('error', log);
+    }
+
+    warn(...args) {
+        let log = this.formatLog(args);
+        return this.base('warn', log);
+    }
+
+    info(...args) {
+        let log = this.formatLog(args);
+        return this.base('info', log);
+    }
+
+    debug(...args) {
+        let log = this.formatLog(args);
+        return this.base('debug', log);
+    }
+
+    base(level, text) {
+        if (!this.request_id || !publisher) {
+            console.log("Return because request or publisher is undefined", this.request_id, publisher);
+            return;
+        }
+
+        let data = {
+            request_id: this.request_id,
+            text: text,
+            level: level,
+            timestamp: new Date(),
+            dev: this.dev
+        }
+
+        publisher.publish(data, (err, ok) => {
+            if (err) console.warn("publish log fail: ", err);
+            return;
+        })
+    }
+
+    formatLog(args) {
+        return args
+            .map(arg => (typeof arg === "object" ? JSON.stringify(arg, null, 2) : arg ))
+            .join(" ")
+    }
+
+}
+
+module.exports = { Logger }

package/TdCache.js

@@ -3,15 +3,12 @@ const redis = require('redis');
 class TdCache {
 
     constructor(config) {
-        console.log("TdCache config: ", config);
+
         this.redis_host = config.host;
         this.redis_port = config.port;
         this.redis_password = config.password;
-        console.log("TdCache this.redis_host: ", this.redis_host);
-        console.log("TdCache this.redis_port: ", this.redis_port);
-        console.log("TdCache this.redis_password: ", this.redis_password);
         this.client = null;
-        this.redis_sub = null;
+        this.subscriberClient = null;
     }
 
     async connect(callback) {
@@ -42,24 +39,24 @@ class TdCache {
             /**
              * Connect redis subscription client
              */
-            this.redis_sub = redis.createClient(
+            this.subscriberClient = redis.createClient(
               {
                 url: `redis://${this.redis_host}:${this.redis_port}`,
                 password: this.redis_password
               });
-            this.redis_sub.on('error', err => {
+            this.subscriberClient.on('error', err => {
                 reject(err);
                 if (callback) {
                     callback(err);
                 }
             });
-            this.redis_sub.on('ready',function() {
+            this.subscriberClient.on('ready',function() {
                 resolve();
                 if (callback) {
                     callback();
                 }
             });
-            await this.redis_sub.connect();
+            await this.subscriberClient.connect();
         });
     }
 
@@ -133,7 +130,25 @@ class TdCache {
     }
     
     async publish(key, value) {
-      await this.redis_sub.publish(key, value);
+      await this.client.publish(key, value);
+    }
+
+    async subscribe(topic, callback) {
+      if (!this.subscriberClient) {
+        throw new Error("Redis subscriber not connected");
+      }
+
+      if (!callback || typeof callback !== 'function') {
+        throw new Error("Callback is mandatory for subscribe")
+      }
+
+      await this.subscriberClient.subscribe(topic, (message) => {
+        callback(message, topic);
+      })
+    }
+
+    async unsubscribe(topic, listener) {
+      await this.subscriberClient.unsubscribe(topic, listener);
     }
 
     // subscribe(key, callback) {

package/index.js

@@ -20,6 +20,7 @@ router.use(bodyParser.json({limit: '50mb'}));
 router.use(bodyParser.urlencoded({ extended: true , limit: '50mb'}));
 
 let log = false;
+/** @type {TdCache} */
 let tdcache = null;
 let MAX_STEPS = 1000;
 let MAX_EXECUTION_TIME = 1000 * 3600 * 8;
@@ -581,46 +582,117 @@ router.post('/echobot', (req, res) => {
   });
 });
 
-// draft webhook
 router.post('/block/:project_id/:bot_id/:block_id', async (req, res) => {
-  const project_id = req.params['project_id'];
-  const bot_id = req.params['bot_id'];
-  const block_id = req.params['block_id'];
+
+  const project_id = req.params.project_id;
+  const bot_id = req.params.bot_id;
+  const block_id = req.params.block_id;
   const body = req.body;
-  if (this.log) {
-    console.log("/block/ .heders:", JSON.stringify(req.headers));
-    console.log("/block/ .body:", JSON.stringify(body));
-  }
-  
-  // console.log('/block/:project_id/:bot_id/:block_id:', project_id, "/", bot_id, "/", block_id);
-  // console.log('/block/:project_id/:bot_id/:block_id.body', body);
+  const async = body.async;
+  const token = body.token;
+  delete body.async;
+  delete body.token;
   
   // invoke block
   // unique ID for each execution
   const execution_id = uuidv4().replace(/-/g, '');
   const request_id = "automation-request-" + project_id + "-" + execution_id;
-  const command = "/" + block_id;
-  let request = {
-    "payload": {
-      "recipient": request_id,
-      "text": command,
-      "id_project": project_id,
-      "request": {
-        "request_id": request_id
+  const command = "/#" + block_id;
+  let message = {
+    payload: {
+      recipient: request_id,
+      text: command,
+      id_project: project_id,
+      request: {
+        request_id: request_id
       },
-      "attributes": {
-        "payload": body
+      attributes: {
+        payload: body
       }
     },
-    "token": "NO-TOKEN"
+    token: token
   }
-  if (this.log) {console.log("sendMessageToBot()...", JSON.stringify(request));}
-  sendMessageToBot(TILEBOT_ENDPOINT, request, bot_id, async () => {
-    res.status(200).send({"success":true});
-    return;
-  });
+
+  if (async) {
+    console.log("Async webhook");
+    sendMessageToBot(TILEBOT_ENDPOINT, message, bot_id, (err, resbody) => {
+      if (err) {
+        console.error("Async err:\n", err);
+        return res.status(500).send({ success: false, error: err });
+      }
+      return res.status(200).send({ success: true });
+    })
+  } else {
+    
+    console.log("Sync webhook. Subscribe and await for reply...")
+    const topic = `/webhooks/${request_id}`;
+    
+    try {
+
+      const listener = async (message, topic) => {
+        console.log("Web response is: ", message, "for topic", topic);
+        await tdcache.unsubscribe(topic, listener);
+
+        let json = JSON.parse(message);
+        let status = json.status ? json.status : 200;
+        console.log("Web response status: ", status);
+
+        return res.status(status).send(json.payload);
+      }
+      await tdcache.subscribe(topic, listener);
+
+    } catch(err) {
+      console.error("Error cache subscribe ", err);
+      return res.status(500).send({ success: false, error: "Error during cache subscription"})
+    }
+
+    sendMessageToBot(TILEBOT_ENDPOINT, message, bot_id, () => {
+      console.log("Sync webhook message sent: ", message);
+    })
+  }
+
 });
 
+// draft webhook
+// router.post('/block/:project_id/:bot_id/:block_id', async (req, res) => {
+//   const project_id = req.params['project_id'];
+//   const bot_id = req.params['bot_id'];
+//   const block_id = req.params['block_id'];
+//   const body = req.body;
+//   if (this.log) {
+//     console.log("/block/ .heders:", JSON.stringify(req.headers));
+//     console.log("/block/ .body:", JSON.stringify(body));
+//   }
+  
+//   // console.log('/block/:project_id/:bot_id/:block_id:', project_id, "/", bot_id, "/", block_id);
+//   // console.log('/block/:project_id/:bot_id/:block_id.body', body);
+  
+//   // invoke block
+//   // unique ID for each execution
+//   const execution_id = uuidv4().replace(/-/g, '');
+//   const request_id = "automation-request-" + project_id + "-" + execution_id;
+//   const command = "/" + block_id;
+//   let request = {
+//     "payload": {
+//       "recipient": request_id,
+//       "text": command,
+//       "id_project": project_id,
+//       "request": {
+//         "request_id": request_id
+//       },
+//       "attributes": {
+//         "payload": body
+//       }
+//     },
+//     "token": "NO-TOKEN"
+//   }
+//   if (this.log) {console.log("sendMessageToBot()...", JSON.stringify(request));}
+//   sendMessageToBot(TILEBOT_ENDPOINT, request, bot_id, async () => {
+//     res.status(200).send({"success":true});
+//     return;
+//   });
+// });
+
 async function startApp(settings, completionCallback) {
   console.log("Starting Tilebot...");
   // console.log("Starting Tilebot with Settings:", settings);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiledesk/tiledesk-tybot-connector",
-  "version": "0.3.4",
+  "version": "0.3.5-rc1",
   "description": "Tiledesk Tybot connector",
   "main": "index.js",
   "scripts": {
@@ -15,6 +15,7 @@
     "@tiledesk/tiledesk-chatbot-client": "^0.5.30",
     "@tiledesk/tiledesk-chatbot-util": "^0.8.39",
     "@tiledesk/tiledesk-client": "^0.10.13",
+    "@tiledesk/tiledesk-multi-worker": "^0.2.1-rc2",
     "accept-language-parser": "^1.5.0",
     "axios": "^1.7.7",
     "body-parser": "^1.19.0",

package/tiledeskChatbotPlugs/DirectivesChatbotPlug.js

@@ -55,6 +55,7 @@ const { DirAddTags } = require('./directives/DirAddTags');
 const { DirSendWhatsapp } = require('./directives/DirSendWhatsapp');
 const { DirReplaceBotV3 } = require('./directives/DirReplaceBotV3');
 const { DirAiTask, DirAiPrompt } = require('./directives/DirAiPrompt');
+const { DirWebResponse } = require('./directives/DirWebResponse');
 
 class DirectivesChatbotPlug {
 
@@ -772,6 +773,12 @@ class DirectivesChatbotPlug {
         }
       });
     }
+    else if (directive_name === Directives.WEB_RESPONSE) {
+      new DirWebResponse(context).execute(directive, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
     else {
       //console.log("Unhandled Post-message Directive:", directive_name);
       let next_dir = await this.nextDirective(this.directives);

package/tiledeskChatbotPlugs/directives/DirIntent.js

@@ -71,11 +71,12 @@ class DirIntent {
         "recipient": requestId,
         "text": intent_command,
         "id_project": projectId,
-        "request": {
-          "request_id": requestId,
-          "id_project": projectId
-          // "bot_id": botId
-        }
+        "request": this.supportRequest,
+        // "request": {
+        //   "request_id": requestId,
+        //   "id_project": projectId
+        //   // "bot_id": botId
+        // }
       },
       "token": this.token
     }

package/tiledeskChatbotPlugs/directives/DirReply.js

@@ -3,6 +3,7 @@ const { TiledeskChatbot } = require('../../models/TiledeskChatbot');
 const { TiledeskChatbotUtil } = require('../../models/TiledeskChatbotUtil');
 let axios = require('axios');
 const { TiledeskClient } = require('@tiledesk/tiledesk-client');
+const { Logger } = require('../../Logger');
 
 class DirReply {
 
@@ -16,6 +17,8 @@ class DirReply {
     this.token = context.token;
     this.tdcache = context.tdcache;
     this.log = context.log;
+    this.supportRequest = this.context.supportRequest;
+    this.logger = new Logger({ request_id: this.requestId, dev: this.context.supportRequest.draft });
 
     this.API_ENDPOINT = context.API_ENDPOINT;
     this.tdClient = new TiledeskClient({
@@ -38,10 +41,14 @@ class DirReply {
     }
     else {
       console.error("Incorrect directive (no action provided):", directive);
+      this.logger.error("Incorrect directive (no action provided):", directive);
       callback();
       return;
     }
+    this.logger.info("Executing Action Reply ", directive.action)
+
     this.go(action, () => {
+      this.logger.info("Action Reply terminated")
       callback();
     });
   }
@@ -64,13 +71,16 @@ class DirReply {
       const filler = new Filler();
       // fill text attribute
       message.text = filler.fill(message.text, requestAttributes);
+
       if (message.metadata) {
         if (this.log) {console.log("filling message 'metadata':", JSON.stringify(message.metadata));}
         if (message.metadata.src) {
           message.metadata.src = filler.fill(message.metadata.src, requestAttributes);
+          this.logger.debug("Filled metadata.src with ", message.metadata.src);
         }
         if (message.metadata.name) {
           message.metadata.name = filler.fill(message.metadata.name, requestAttributes);
+          this.logger.debug("Filled metadata.name with ", message.metadata.name);
         }
       }
       if (this.log) {console.log("filling commands'. Message:", JSON.stringify(message));}
@@ -84,6 +94,7 @@ class DirReply {
             let command = commands[i];
             if (command.type === 'message' && command.message && command.message.text) {
               command.message.text = filler.fill(command.message.text, requestAttributes);
+              this.logger.debug("Filled message.text with ", command.message.text)
               TiledeskChatbotUtil.fillCommandAttachments(command, requestAttributes, this.log);
               if (this.log) {console.log("command filled:", command.message.text);}
             }
@@ -133,12 +144,14 @@ class DirReply {
           }
           catch(err) {
             console.error("An error occurred while JSON.parse(). Parsed value:" + value + " in allParametersStatic(). Error:", err);
+            this.logger.error("An error occurred while JSON.parse(). Parsed value:" + value + " in allParametersStatic(). Error:", err);
           }
         }
       }
     }
     // send!
     let cleanMessage = message;
+    this.logger.info("Sending reply with text ", cleanMessage.text);
     // cleanMessage = TiledeskChatbotUtil.removeEmptyReplyCommands(message);
     // if (!TiledeskChatbotUtil.isValidReply(cleanMessage)) {
     //   console.log("invalid message", cleanMessage);
@@ -156,8 +169,10 @@ class DirReply {
       (err) => {
         if (err) {
           console.error("Error sending reply:", err);
+          this.logger.error("Error sending reply ", err.response.data);
         }
         if (this.log) {console.log("Reply message sent:", JSON.stringify(cleanMessage));}
+        this.logger.info("Reply message sent!", cleanMessage.text);
         const delay = TiledeskChatbotUtil.totalMessageWait(cleanMessage);
         // console.log("got total delay:", delay)
         if (delay > 0 && delay <= 30000) { // prevent long delays