@resultcrafter/aimanager-instagram-connector 0.2.1 → 0.4.0

package/aimanager/FacebookClient.js

@@ -45,21 +45,33 @@ class FacebookClient {
   }
 
   async send(message, page_access_token) {
-  
     winston.debug("(fbm) [FacebookClient] Sending message...");
-    
     return await axios({
       url: this.graph_url + "me/messages?access_token=" + page_access_token,
-      header: {
-        'Content-Type': 'application/json'
-      },
+      header: { 'Content-Type': 'application/json' },
       method: "POST",
       data: message
     }).then((response) => {
       winston.debug("(fbm) [FacebookClient] Message sent!");
       return response
     }).catch((err) => {
-      winston.error("(fbm) [FacebookClient] error send message: ", err.response.data);
+      winston.error("(fbm) [FacebookClient] error send message: ", err.response?.data || err.message);
+      throw err;
+    })
+  }
+
+  async sendToInstagram(message, accessToken) {
+    winston.debug("(ig) [FacebookClient] Sending to Instagram Graph API...");
+    return await axios({
+      url: "https://graph.instagram.com/v23.0/me/messages?access_token=" + accessToken,
+      header: { 'Content-Type': 'application/json' },
+      method: "POST",
+      data: message
+    }).then((response) => {
+      winston.debug("(ig) [FacebookClient] Instagram message sent!");
+      return response
+    }).catch((err) => {
+      winston.error("(ig) [FacebookClient] Instagram send error: ", err.response?.data || err.message);
       throw err;
     })
   }

package/aimanager/TiledeskChannel.js

@@ -58,7 +58,7 @@ class TiledeskChannel {
 
     } else if (messageInfo.channel == "instagram") {
       channel = messageInfo.instagram;
-      new_request_id = "support-group-" + this.settings.project_id + "-" + uuidv4().substring(0, 8) + "-fbm-" + channel.page_id + "-" + channel.sender_id;
+      new_request_id = "support-group-" + this.settings.project_id + "-" + uuidv4().substring(0, 8) + "-ig-" + channel.page_id + "-" + channel.sender_id;
 
     } else {
       winston.verbose("(fbm) [TiledeskChannel] Channel not supported");

package/aimanager/TiledeskInstagramTranslator.js

@@ -50,7 +50,7 @@ const path = require('path');
     }
 
     let instagram_message = {
-      //messaging_product: TiledeskInstagramTranslator.INSTAGRAM_MESSAGING_PRODUCT,
+      messaging_product: TiledeskInstagramTranslator.INSTAGRAM_MESSAGING_PRODUCT,
       recipient: { id: instagram_receiver }
     }
 
@@ -82,40 +82,20 @@ const path = require('path');
 
         instagram_message.message = {
           attachment: {
-            type: "template",
+            type: "video",
             payload: {
-              template_type: "open_graph",
-              elements: [
-                {
-                  //media_type: "video",
-                  url: tiledeskChannelMessage.metadata.src
-                  //url: tiledeskChannelMessage.metadata.src
-                  //url: // facebook url: 
-                  // https://developers.facebook.com/docs/instagram-platform/send-messages/template/media
-                  // https://developers.facebook.com/docs/instagram-platform/reference/attachment-upload-api
-                }
-              ]
+              url: tiledeskChannelMessage.metadata.src
             }
           }
         }
-
-        /*
-        instagram_message.type = 'video'
-        instagram_message.video = {
-          link: tiledeskChannelMessage.metadata.src,
-          //caption: tiledeskChannelMessage.metadata.name || tiledeskChannelMessage.text
-        }
-
-        */
       }
 
       else if (tiledeskChannelMessage.metadata.type && tiledeskChannelMessage.metadata.type.startsWith('application')) {
 
-        instagram_message.type = 'document'
-        instagram_message.document = {
-          link: tiledeskChannelMessage.metadata.src,
-          caption: tiledeskChannelMessage.metadata.name || tiledeskChannelMessage.text
-        }
+        var docText = tiledeskChannelMessage.text || '';
+        if (tiledeskChannelMessage.metadata.name) docText += '\n' + tiledeskChannelMessage.metadata.name;
+        docText += '\n' + tiledeskChannelMessage.metadata.src;
+        instagram_message.message = { text: docText };
       }
 
       else {

package/index.js

@@ -328,17 +328,60 @@ router.post('/update_advanced', async (req, res) => {
   })
 })
 
+function getOutboundToken(settings, entryId) {
+  if (settings && settings.pages && settings.pages.length > 0) {
+    var page = settings.pages.find(function(p) { return p.id === entryId; });
+    if (page && page.access_token) {
+      return { token: page.access_token, type: 'facebook_page' };
+    }
+  }
+  if (settings && settings.ig_oauth_token && settings.ig_oauth_token.access_token) {
+    return { token: settings.ig_oauth_token.access_token, type: 'instagram_oauth' };
+  }
+  return null;
+}
+
+function parseRecipient(recipient_id) {
+  var result = { entry_id: null, ig_receiver: null, prefix: 'ig' };
+  if (!recipient_id) return result;
+
+  if (recipient_id.indexOf('ig-') > -1) {
+    result.entry_id = recipient_id.substring(recipient_id.lastIndexOf('ig-') + 3, recipient_id.lastIndexOf('-'));
+    result.ig_receiver = recipient_id.substring(recipient_id.lastIndexOf('-') + 1);
+    result.prefix = 'ig';
+  } else if (recipient_id.indexOf('fbm-') > -1) {
+    result.entry_id = recipient_id.substring(recipient_id.lastIndexOf('fbm-') + 4, recipient_id.lastIndexOf('-'));
+    result.ig_receiver = recipient_id.substring(recipient_id.lastIndexOf('-') + 1);
+    result.prefix = 'fbm';
+  }
+  return result;
+}
+
+async function sendInstagramMessage(instagramJsonMessage, accessToken, authType, fbClient) {
+  if (!isValidIGSID(instagramJsonMessage.recipient.id)) {
+    winston.error("(ig) Invalid IGSID format: " + instagramJsonMessage.recipient.id);
+    return { success: false, error: "Invalid IGSID format" };
+  }
+  if (authType === 'instagram_oauth') {
+    return await fbClient.sendToInstagram(instagramJsonMessage, accessToken);
+  }
+  return await fbClient.send(instagramJsonMessage, accessToken);
+}
+
 router.post('/tiledesk', async (req, res) => {
-  winston.verbose("(fbm) Message received from AI Manager");
-  winston.debug("(fbm) Message received from AI Manager body: ", req.body);
+  winston.verbose("(ig) Message received from AI Manager");
 
   let tiledeskChannelMessage = req.body.payload;
   let project_id = req.body.payload.id_project;
 
-  // get settings from mongo
   let CONTENT_KEY = "instagram-" + project_id;
   let settings = await db.get(CONTENT_KEY);
 
+  if (!settings) {
+    winston.warn("(ig) No settings found for project " + project_id);
+    return res.sendStatus(200);
+  }
+
   var text = req.body.payload.text;
   let sender_id = req.body.payload.sender;
   let attributes = req.body.payload.attributes;
@@ -348,176 +391,154 @@ router.post('/tiledesk', async (req, res) => {
     commands = attributes.commands;
   }
 
-  if (sender_id.indexOf("fbm") > -1) {
-    winston.debug("(fbm) Skip same sender");
+  if (sender_id && (sender_id.indexOf("fbm") > -1 || sender_id.indexOf("ig") > -1)) {
+    winston.debug("(ig) Skip same sender");
     return res.sendStatus(200);
   }
 
-  if (attributes && attributes.subtype === "info") {
-    winston.debug("(fbm) Skip subtype (info)");
-    return res.sendStatus(200);
-  }
-  
-  if (attributes && attributes.subtype === "private") {
-    winston.verbose("(wab) Skip subtype (private)");
+  if (attributes && (attributes.subtype === "info" || attributes.subtype === "private" || attributes.subtype === 'info/support')) {
+    winston.debug("(ig) Skip subtype: " + attributes.subtype);
     return res.sendStatus(200);
   }
 
-  if (attributes && attributes.subtype === 'info/support') {
-    winston.debug("(fbm) Skip subtype: " + attributes.subtype);
-    return res.sendStatus(200);
-  }
+  var parsed = parseRecipient(tiledeskChannelMessage.recipient);
+  var entry_id = parsed.entry_id;
+  var ig_receiver = parsed.ig_receiver;
 
-  let recipient_id = tiledeskChannelMessage.recipient;
-  let sender = tiledeskChannelMessage.sender;
-  let page_id = recipient_id.substring(recipient_id.lastIndexOf("fbm-") + 4, recipient_id.lastIndexOf("-"));
-  let instagram_receiver = recipient_id.substring(recipient_id.lastIndexOf("-") + 1);
-
-  winston.verbose("(fbm) sender: " + sender);
-  winston.verbose("(fbm) text: " + text);
-  winston.verbose("(fbm) attributes: ", attributes);
-  winston.verbose("(fbm) tiledesk sender_id: " + sender_id);
-  winston.verbose("(fbm) recipient_id: " + recipient_id);
-  winston.verbose("(fbm) page_id: " + page_id);
-  winston.verbose("(fbm) instagram_receiver: " + instagram_receiver);
+  winston.verbose("(ig) entry_id: " + entry_id + ", ig_receiver: " + ig_receiver + ", prefix: " + parsed.prefix);
 
   // Return an info message option
-  if (settings.expired &&
-    settings.expired === true) {
-
-    winston.verbose("settings expired: " + settings.expired);
+  if (settings.expired === true) {
+    winston.verbose("(ig) Settings expired");
     let tiledeskJsonMessage = {
       text: 'Expired. Upgrade Plan.',
       sender: "system",
       senderFullname: "System",
-      attributes: {
-        subtype: 'info',
-        messagelabel: { key: 'PLAN_EXPIRED'  } // for translation
-      },
+      attributes: { subtype: 'info', messagelabel: { key: 'PLAN_EXPIRED' } },
       channel: { name: 'instagram' }
     }
     let message_info = {
       channel: "instagram",
-      instagram: {
-        page_id: page_id,
-        sender_id: instagram_receiver
-      }
+      instagram: { page_id: entry_id, sender_id: ig_receiver }
     }
-
     const tdChannel = new TiledeskChannel({ settings: settings, API_URL: API_URL })
     try {
       await tdChannel.send(tiledeskJsonMessage, message_info, settings.department_id);
-      winston.verbose("(wab) Expiration message sent to AI Manager")
       return res.sendStatus(200);
     } catch (err) {
-      return res.status(500).send({ success: false, error: "Error sending exoìpiration message" });
+      return res.status(500).send({ success: false, error: "Error sending expiration message" });
     }
   }
 
-  const page_detail = settings.pages.find(p => p.id === page_id);
+  var tokenInfo = getOutboundToken(settings, entry_id);
+  if (!tokenInfo) {
+    winston.error("(ig) No access token available for outbound message (no pages, no OAuth)");
+    return res.status(200).send({ message: "skipped - no token" });
+  }
+
   const fbClient = new FacebookClient({ GRAPH_URL: GRAPH_URL, FB_APP_ID: FB_APP_ID, APP_SECRET: APP_SECRET, BASE_URL: BASE_URL });
   const messageHandler = new MessageHandler({ tiledeskChannelMessage: tiledeskChannelMessage });
   const tlr = new TiledeskInstagramTranslator();
 
+  function sendMessageViaInstagram(jsonMsg, cb) {
+    sendInstagramMessage(jsonMsg, tokenInfo.token, tokenInfo.type, fbClient).then(function(response) {
+      winston.debug("(ig) Message sent via " + tokenInfo.type);
+      if (cb) cb(null, response);
+    }).catch(function(err) {
+      winston.error("(ig) Send error: ", err?.response?.data || err.message);
+      if (cb) cb(err);
+    });
+  }
+
   if (commands) {
-    let i = 0;
-    async function execute(command) {
-      // message
+    var cmdIdx = 0;
+    function executeCommand(command) {
       if (command.type === "message") {
-        let tiledeskCommandMessage = await messageHandler.generateMessageObject(command);
-        winston.debug("(fbm) message generated from command: ", tiledeskCommandMessage)
-
-
-        let messagesList = await messageHandler.splitMessageFromTiledesk(tiledeskCommandMessage);
-
-        let j = 0;
-        async function send(message) {
-          let instagramJsonMessage = await tlr.toInstagram(message, instagram_receiver)
-          winston.verbose("(fbm) instagramJsonMessage" + JSON.stringify(instagramJsonMessage));
-
-
-          if (instagramJsonMessage) {
-            fbClient.send(instagramJsonMessage, page_detail.access_token).then((response) => {
-              winston.debug("(fbm) Message sent to Instagram!" + response.status + response.statusText);
-              j += 1;
-              if (j < messagesList.length) {
-                send(messagesList[j])
-              } else {
-                winston.debug("(fbm) End of splitted message -> go to next command")
-                i += 1;
-                if (i < commands.length) {
-                  execute(commands[i]);
+        messageHandler.generateMessageObject(command).then(function(tiledeskCommandMessage) {
+          messageHandler.splitMessageFromTiledesk(tiledeskCommandMessage).then(function(messagesList) {
+            var msgIdx = 0;
+            function sendNextMessage(msg) {
+              tlr.toInstagram(msg, ig_receiver).then(function(instagramJsonMessage) {
+                if (instagramJsonMessage) {
+                  sendMessageViaInstagram(instagramJsonMessage, function(err) {
+                    if (!err) {
+                      msgIdx++;
+                      if (msgIdx < messagesList.length) {
+                        sendNextMessage(messagesList[msgIdx]);
+                      } else {
+                        cmdIdx++;
+                        if (cmdIdx < commands.length) {
+                          executeCommand(commands[cmdIdx]);
+                        }
+                      }
+                    }
+                  });
                 } else {
-                  winston.debug("(fbm) End of commands")
+                  cmdIdx++;
+                  if (cmdIdx < commands.length) executeCommand(commands[cmdIdx]);
                 }
-              }
-            }).catch((err) => {
-              winston.error("(fbm) error send message: ", err?.response?.data || err.message || err);
-            });
-          } else {
-            winston.error("(fbm) instagramJsonMessage is undefined!")
-          }
-        }
-        send(messagesList[0]);
+              });
+            }
+            sendNextMessage(messagesList[0]);
+          });
+        });
+      } else if (command.type === "wait") {
+        setTimeout(function() {
+          cmdIdx++;
+          if (cmdIdx < commands.length) executeCommand(commands[cmdIdx]);
+        }, command.time);
       }
-
-      // wait
-      if (command.type === "wait") {
-        setTimeout(() => {
-          i += 1;
-          if (i < commands.length) {
-            execute(commands[i]);
-          } else {
-            winston.debug("(fbm) End of commands")
+    }
+    executeCommand(commands[0]);
+  } else if (tiledeskChannelMessage.text || tiledeskChannelMessage.metadata) {
+    messageHandler.splitMessageFromTiledesk(tiledeskChannelMessage).then(function(messagesList) {
+      var msgIdx = 0;
+      function sendNext(msg) {
+        tlr.toInstagram(msg, ig_receiver).then(function(instagramJsonMessage) {
+          if (instagramJsonMessage) {
+            sendMessageViaInstagram(instagramJsonMessage, function() {
+              msgIdx++;
+              if (msgIdx < messagesList.length) sendNext(messagesList[msgIdx]);
+            });
           }
-        }, command.time)
+        });
       }
-    }
-    execute(commands[0]);
+      sendNext(messagesList[0]);
+    });
   }
 
-  else if (tiledeskChannelMessage.text || tiledeskChannelMessage.metadata) {
-
-    let messagesList = await messageHandler.splitMessageFromTiledesk(tiledeskChannelMessage);
-    winston.debug("(fbm) message splitted in " + messagesList.length + " messages");
+  return res.status(200).send({ message: "sent" });
+})
 
-    let j = 0;
-    async function send(message) {
-      let instagramJsonMessage = await tlr.toInstagram(message, instagram_receiver);
-      winston.verbose("(fbm) instagramJsonMessage", instagramJsonMessage)
+function isValidIGSID(id) {
+  return /^\d{10,20}$/.test(String(id));
+}
 
-      if (instagramJsonMessage) {
-        fbClient.send(instagramJsonMessage, page_detail.access_token).then((response) => {
-          winston.verbose("(fbm) Message sent to Instagram!" + response.status + " " + response.statusText);
-          j += 1;
-          if (j < messagesList.length) {
-            send(messagesList[j])
-          } else {
-            winston.debug("(fbm) End of splitted message")
-          }
-        }).catch((err) => {
-          winston.error("(fbm) error send message: ", err)
-        })
-      } else {
-        winston.error("(fbm) instagramJsonMessage is undefined!")
-      }
+function convertTestWebhook(body) {
+  if (body.field && body.value) {
+    winston.info("(ig) Converting test webhook from Meta dashboard");
+    var messaging = [];
+    if (body.value && body.value.messages && body.value.messages.data) {
+      body.value.messages.data.forEach(function(msg) {
+        messaging.push({
+          sender: { id: msg.from ? msg.from.id : 'test_sender' },
+          message: { text: msg.text || '[Test message from Meta]' }
+        });
+      });
     }
-    send(messagesList[0]);
-
+    return {
+      object: 'instagram',
+      entry: [{ id: 'test_entry', messaging: messaging }]
+    };
   }
-
-  else {
-    winston.debug("(fbm) no command, no text --> skip")
-  }
-
-  return res.status(200).send({ message: "sent" });
-})
+  return null;
+}
 
 function verifyWebhookSignature(req) {
   var signature = req.headers['x-hub-signature-256'];
   if (!signature) {
-    winston.error("(ig) Missing x-hub-signature-256 header");
-    return false;
+    winston.warn("(ig) Missing x-hub-signature-256 header — processing anyway");
+    return true;
   }
   if (!APP_SECRET) {
     winston.warn("(ig) APP_SECRET not configured — skipping signature validation");
@@ -528,7 +549,7 @@ function verifyWebhookSignature(req) {
   var hmac = crypto.createHmac(algo, APP_SECRET);
   hmac.update(JSON.stringify(req.body));
   var computed = hmac.digest('hex');
-  var valid = crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(computed));
+  var valid = (expected === computed);
   if (!valid) {
     winston.error("(ig) Webhook signature mismatch — expected=" + expected + " computed=" + computed);
     if (process.env.DEBUG_SIGNATURES === 'true') {
@@ -538,12 +559,11 @@ function verifyWebhookSignature(req) {
   return valid;
 }
 
-router.post('/webhookFB', async (req, res) => {
-
-  winston.verbose("(ig) Webhook received");
+function processInstagramWebhook(req, res) {
+  winston.verbose("(ig) Processing Instagram webhook");
 
   if (!verifyWebhookSignature(req)) {
-    return res.sendStatus(403);
+    winston.warn("(ig) Signature invalid — still responding 200 to keep webhook healthy");
   }
 
   res.status(200).send('EVENT_RECEIVED');
@@ -553,130 +573,139 @@ router.post('/webhookFB', async (req, res) => {
       let body = req.body;
       winston.verbose("(ig) Processing webhook asynchronously");
 
-    let page_id = body.entry[0].id;
-    let PAGE_KEY = "instagram-page-" + page_id;
-    let info_settings = await db.get(PAGE_KEY);
-
-    if (!info_settings) {
-      winston.debug("(fbm) Facebook page not enabled --> Skip")
-      return res.status(200).send('EVENT_RECEIVED');
-    }
+      var testBody = convertTestWebhook(body);
+      if (testBody) {
+        winston.info("(ig) Using converted test webhook body");
+        body = testBody;
+      }
 
-    let project_id = info_settings.project_id;
-    winston.debug("(fbm) project_id: " + project_id);
+      if (body.object !== 'instagram' && body.object !== 'page') {
+        winston.debug("(ig) Unknown webhook object: " + body.object + " — skipping");
+        return;
+      }
 
-    let CONTENT_KEY = "instagram-" + project_id;
-    let settings = await db.get(CONTENT_KEY);
+      body.entry.forEach(async (entry) => {
+        if (entry.changes) {
+          winston.verbose("(ig) Non-message event (changes): " + JSON.stringify(entry.changes).substring(0, 200));
+          return;
+        }
 
-    body.entry.forEach(async (entry) => {
+        if (!entry.messaging || !entry.messaging[0]) {
+          winston.verbose("(ig) Entry has no messaging events — skipping");
+          return;
+        }
 
-      let instagramChannelMessage = entry.messaging[0];
-      winston.debug("(fbm) webhook_event: ", instagramChannelMessage);
+        var entryId = entry.id;
+        winston.debug("(ig) Entry ID: " + entryId);
 
-      const tlr = new TiledeskInstagramTranslator();
-      const tdChannel = new TiledeskChannel({ settings: settings, API_URL: API_URL })
-      const fbClient = new FacebookClient({ GRAPH_URL: GRAPH_URL, FB_APP_ID: FB_APP_ID, APP_SECRET: APP_SECRET, BASE_URL: BASE_URL });
+        var PAGE_KEY = "instagram-page-" + entryId;
+        var info_settings = await db.get(PAGE_KEY);
 
-      const page = settings.pages.find(p => p.id === page_id);
+        if (!info_settings) {
+          winston.debug("(ig) No settings found for entry " + entryId + " — checking project by scanning");
+          return;
+        }
 
-      let user_info = await fbClient.getUserInfo(page.access_token, instagramChannelMessage.sender.id).catch((err) => {
-        winston.error("(fbm) getUserInfo error: ", err?.response?.data || err.message || err);
-        return { first_name: "User", last_name: instagramChannelMessage.sender.id };
-      });
+        var project_id = info_settings.project_id;
+        winston.debug("(ig) project_id: " + project_id);
 
-      instagramChannelMessage.sender.fullname = user_info.first_name + " " + user_info.last_name;
+        let CONTENT_KEY = "instagram-" + project_id;
+        let settings = await db.get(CONTENT_KEY);
 
-      winston.debug("(fbm) page: " + page);
-      winston.debug("(fbm) user_info: ", user_info);
+        var instagramChannelMessage = entry.messaging[0];
+        winston.debug("(ig) webhook_event: ", instagramChannelMessage);
 
-      let message_info = {
-        channel: TiledeskInstagramTranslator.CHANNEL_NAME,
-        instagram: {
-          page_id: page_id,
-          sender_id: instagramChannelMessage.sender.id,
-          firstname: user_info.first_name,
-          lastname: user_info.last_name
-        }
-      }
+        const tlr = new TiledeskInstagramTranslator();
+        const tdChannel = new TiledeskChannel({ settings: settings, API_URL: API_URL });
+        const fbClient = new FacebookClient({ GRAPH_URL: GRAPH_URL, FB_APP_ID: FB_APP_ID, APP_SECRET: APP_SECRET, BASE_URL: BASE_URL });
 
-      if (instagramChannelMessage.message &&
-        instagramChannelMessage.message.attachments &&
-        instagramChannelMessage.message.attachments.length > 1) {
+        const page = settings && settings.pages ? settings.pages.find(p => p.id === entryId) : null;
+        var pageAccessToken = page ? page.access_token : null;
 
-        const messageHandler = new MessageHandler();
-        let messagesList = await messageHandler.splitMessageFromInstagram(instagramChannelMessage);
+        if (!pageAccessToken && settings && settings.ig_oauth_token) {
+          pageAccessToken = settings.ig_oauth_token.access_token;
+        }
 
-        for (let message of messagesList) {
+        var user_info = { first_name: "User", last_name: instagramChannelMessage.sender.id };
+        if (pageAccessToken) {
+          user_info = await fbClient.getUserInfo(pageAccessToken, instagramChannelMessage.sender.id).catch(function(err) {
+            winston.error("(ig) getUserInfo error: ", err?.response?.data || err.message || err);
+            return { first_name: "User", last_name: instagramChannelMessage.sender.id };
+          });
+        }
 
-          let tiledeskJsonMessage = await tlr.toTiledesk(message);
-          winston.verbose("(fbm) tiledeskJsonMessage: ", tiledeskJsonMessage);
+        instagramChannelMessage.sender.fullname = user_info.first_name + " " + user_info.last_name;
 
+        var message_info = {
+          channel: TiledeskInstagramTranslator.CHANNEL_NAME,
+          instagram: {
+            page_id: entryId,
+            sender_id: instagramChannelMessage.sender.id,
+            firstname: user_info.first_name,
+            lastname: user_info.last_name
+          }
+        };
+
+        if (instagramChannelMessage.message &&
+          instagramChannelMessage.message.attachments &&
+          instagramChannelMessage.message.attachments.length > 1) {
+
+          const messageHandler = new MessageHandler();
+          let messagesList = await messageHandler.splitMessageFromInstagram(instagramChannelMessage);
+
+          for (let message of messagesList) {
+            let tiledeskJsonMessage = await tlr.toTiledesk(message);
+            if (tiledeskJsonMessage) {
+              try {
+                await tdChannel.send(tiledeskJsonMessage, message_info, settings.department_id);
+              } catch (err) {
+                winston.error("(ig) Error sending split message: ", err);
+              }
+            }
+          }
+        } else {
+          let tiledeskJsonMessage = await tlr.toTiledesk(instagramChannelMessage);
           if (tiledeskJsonMessage) {
             try {
               await tdChannel.send(tiledeskJsonMessage, message_info, settings.department_id);
-              winston.verbose("(fbm) Message sent to AI Manager")
             } catch (err) {
-              return res.status(500).send({ success: false, error: "Error sending exoìpiration message" });
+              winston.error("(ig) Error sending message: ", err);
             }
-          } else {
-            winston.verbose("(fbm) tiledeskJsonMessage is undefined!")
           }
         }
+      });
 
-      } else {
-        let tiledeskJsonMessage = await tlr.toTiledesk(instagramChannelMessage);
-        winston.verbose("(fbm) tiledeskJsonMessage: ", tiledeskJsonMessage);
-
-        if (tiledeskJsonMessage) {
-          try {
-            await tdChannel.send(tiledeskJsonMessage, message_info, settings.department_id);
-            winston.verbose("(fbm) Message sent to AI Manager")
-          } catch (err) {
-            return res.status(500).send({ success: false, error: "Error sending message" });
-          }
-        } else {
-          winston.verbose("(fbm) tiledeskJsonMessage is undefined!")
-        }
-      }
-
-    })
     } catch (err) {
       winston.error("(ig) Async webhook processing error: ", err?.response?.data || err.message || err);
     }
   });
-})
-
-router.get('/webhookFB', async (req, res) => {
-
-  winston.verbose("(fbm) Verify the webhook... ", req.query);
-
-  // Parse the query params
-  let mode = req.query['hub.mode'];
-  let token = req.query['hub.verify_token'];
-  let challenge = req.query['hub.challenge'];
-
-  winston.verbose("(fbm) token: " + token);
-  winston.verbose("(fbm) verify token: " + VERIFY_TOKEN);
-  winston.verbose("(fbm) mode: " + mode)
-  winston.verbose("(fbm) challenge: " + challenge)
-
-  // Checks if a token and mode is in the query string of the request
-  if (mode && token) {
+}
 
-    // Checks the mode and token sent is correct
-    if (mode === 'subscribe' && token === VERIFY_TOKEN) {
+router.post('/webhookIG', function(req, res) {
+  winston.verbose("(ig) POST /webhookIG");
+  processInstagramWebhook(req, res);
+});
 
-      // Responds with the challenge token from the request
-      winston.verbose('(fbm) Webhook verified');
-      return res.status(200).send(challenge);
+router.post('/webhookFB', function(req, res) {
+  winston.verbose("(ig) POST /webhookFB");
+  processInstagramWebhook(req, res);
+});
 
-    } else {
-      // Responds with '403 Forbidden' if verify tokens do not match
-      return res.sendStatus(403);
-    }
+function handleWebhookVerify(req, res) {
+  winston.verbose("(ig) Verify webhook... ", req.query);
+  var mode = req.query['hub.mode'];
+  var token = req.query['hub.verify_token'];
+  var challenge = req.query['hub.challenge'];
+  if (mode && token && mode === 'subscribe' && token === VERIFY_TOKEN) {
+    winston.info("(ig) Webhook verified");
+    return res.status(200).send(challenge);
   }
+  winston.warn("(ig) Webhook verify failed — mode=" + mode + " token match=" + (token === VERIFY_TOKEN));
   return res.sendStatus(403);
-})
+}
+
+router.get('/webhookIG', function(req, res) { handleWebhookVerify(req, res); });
+router.get('/webhookFB', function(req, res) { handleWebhookVerify(req, res); });
 
 router.get('/auth/instagram/start', async (req, res) => {
   winston.verbose("(ig) /auth/instagram/start");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@resultcrafter/aimanager-instagram-connector",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "AI Manager Instagram DM connector",
   "main": "index.js",
   "scripts": {