@resultcrafter/aimanager-instagram-connector 0.1.0

package/LICENSE

@@ -0,0 +1,26 @@
+MIT License
+
+Copyright (c) 2024 Tiledesk SRL (original work)
+Copyright (c) 2026 ResultCrafter (modifications)
+
+This software is derived from @tiledesk/tiledesk-messenger-connector (MIT License)
+and @tiledesk/tiledesk-telegram-connector (MIT License).
+See https://github.com/Tiledesk/tiledesk-telegram-connector for original source.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,50 @@
+# AI Manager Instagram DM Connector
+
+> Instagram Direct Messages connector for [AI Manager](https://aimanager-app.pages.dev).
+
+This package allows AI Manager to receive and reply to Instagram Direct Messages. Agents handle Instagram conversations from the unified dashboard alongside Telegram, WhatsApp, Messenger, and web widget channels.
+
+## License & Attribution
+
+**MIT License** — see [LICENSE](./LICENSE).
+
+This software is derived from:
+- [`@tiledesk/tiledesk-messenger-connector`](https://www.npmjs.com/package/@tiledesk/tiledesk-messenger-connector) (MIT) — base blueprint
+- [`@tiledesk/tiledesk-telegram-connector`](https://github.com/Tiledesk/tiledesk-telegram-connector) (MIT) — architecture reference
+
+All original Tiledesk packages are MIT licensed. This package retains the MIT license and copyright notice as required.
+
+## Status
+
+**Under development.** The repo is seeded from the Messenger connector with all references renamed. Remaining work per the [implementation plan](./docs/proposal.md):
+
+1. Replace basic config form with Instagram OAuth flow
+2. Adapt FacebookClient.js for Instagram Graph API
+3. Wire up webhook handlers for Instagram DM payloads
+4. Add Dashboard UI constants and badges
+5. Register as AI Manager server pubmodule
+
+See the full plan in [`docs/proposal.md`](./docs/proposal.md).
+
+## Documentation
+
+| Document | Description |
+|----------|-------------|
+| [`docs/proposal.md`](./docs/proposal.md) | Instagram connector implementation proposal |
+| [`docs/design.md`](./docs/design.md) | Technical design decisions |
+| [`docs/specs/`](./docs/specs/) | Requirements and scenarios |
+| [`docs/tasks.md`](./docs/tasks.md) | Implementation tasks |
+| [`docs/adding-new-channel-guide.md`](./docs/adding-new-channel-guide.md) | Universal guide for adding any channel to AI Manager |
+| [`docs/connector-research-proposal.md`](./docs/connector-research-proposal.md) | Research findings on existing connectors |
+
+## Quick Start
+
+```bash
+npm install
+npm start
+```
+
+## Related
+
+- [AI Manager](https://aimanager-app.pages.dev)
+- [Tiledesk Telegram Connector](https://github.com/Tiledesk/tiledesk-telegram-connector) (MIT)

package/aimanager/FacebookClient.js

@@ -0,0 +1,223 @@
+const axios = require("axios").default;
+const fs = require('fs');
+const FormData = require('form-data');
+const path = require('path');
+const winston = require('../winston');
+
+class FacebookClient {
+  /**
+    * Constructor for FacebookClient
+    *
+    * @example
+    * const fbClient = new FacebookClient({ GRAPH_URL: GRAPH_URL, APP_ID: APP_ID, APP_SECRET: APP_SECRET, BASE_URL: BASE_URL });
+    * 
+    * @param {Object} config JSON configuration.
+    * @param {string} config.GRAPH_URL Mandatory. The api url for facebook.
+    * @param {string} config.APP_ID Mandatory. The facebook developer app id.
+    * @param {boolean} options.log Optional. If true HTTP requests are logged.
+    */
+
+  constructor(config) {
+    if (!config) {
+      throw new Error('config is mandatory');
+    }
+
+    if (!config.GRAPH_URL) {
+      throw new Error('config.GRAPH_URL is mandatory');
+    }
+
+    if (!config.FB_APP_ID) {
+      throw new Error('config.APP_ID is mandatory')
+    }
+
+    if (!config.APP_SECRET) {
+      throw new Error('config.APP_SECRET is mandatory')
+    }
+
+    if (!config.BASE_URL) {
+      throw new Error('config.BASE_URL is mandatory')
+    }
+
+    this.graph_url = config.GRAPH_URL;
+    this.app_id = config.FB_APP_ID;
+    this.app_secret = config.APP_SECRET;
+    this.base_url = config.BASE_URL;
+  }
+
+  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'
+      },
+      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);
+      throw err;
+    })
+  }
+
+  async getAccessTokenFromCode(code, callback) {
+
+    const params = {
+      client_id: this.app_id,
+      client_secret: this.app_secret,
+      redirect_uri: this.base_url + '/oauth',
+      code: code
+    }
+
+    const URL = this.graph_url + 'oauth/access_token';
+    //const URL = "https://graph.facebook.com/v9.0/oauth/access_token";
+    const HTTPREQUEST = {
+      url: URL,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      params: params,
+      json: true,
+      method: 'GET'
+    }
+    let promise = new Promise((resolve, reject) => {
+      FacebookClient.myrequest(
+        HTTPREQUEST,
+        function(err, resbody) {
+          if (err) {
+            if (callback) {
+              callback(err);
+            }
+            reject(err);
+          }
+          else {
+            if (callback) {
+              callback(null, resbody);
+            }
+            resolve(resbody.access_token);
+          }
+        }, true)
+    })
+    return promise;
+  }
+
+  async getPages(access_token, callback) {
+
+    const params = {
+      access_token: access_token
+    }
+
+    const URL = this.graph_url + 'me/accounts';
+    const HTTPREQUEST = {
+      url: URL,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      params: params,
+      method: 'GET'
+    }
+    let promise = new Promise((resolve, reject) => {
+      FacebookClient.myrequest(
+        HTTPREQUEST,
+        function(err, resbody) {
+          if (err) {
+            if (callback) {
+              callback(err);
+            }
+            reject(err);
+          }
+          else {
+            if (callback) {
+              callback(null, resbody);
+            }
+            resolve(resbody.data);
+          }
+        }, true)
+    })
+    return promise;
+  }
+
+  async messageEventSubscription(page_id, access_token) {
+
+    return await axios({
+      url: this.graph_url + page_id + "/subscribed_apps?access_token=" + access_token + "&subscribed_fields=['messages', 'messaging_postbacks']",
+      method: "POST"
+    }).then((response) => {
+      winston.debug("(fbm) [FacebookClient] event subscription resbody: ", response);
+      return response
+    }).catch((err) => {
+      winston.error("(fbm) [FacebookClient] event subscription error: ", err)
+    })
+
+    /*
+    let promise = new Promise((resolve, reject) => {
+      
+      request({
+        url: `${this.graph_url}/${page_id}/subscribed_apps?access_token=${access_token}&subscribed_fields=messages`,
+        method: 'POST'
+      }, (err, res, resbody) => {
+        if (err) {
+          reject(err)
+        } else {
+          resolve(resbody)
+        }
+      })
+    })
+    return promise;
+    */
+  }
+
+  async getUserInfo(access_token, user_id) {
+    try {
+      const response = await axios({
+        url: this.graph_url + user_id + "?access_token=" + access_token,
+        method: 'GET'
+      });
+      winston.debug("(fbm) [FacebookClient] get user info response: ", response.data);
+      return response.data;
+    } catch (err) {
+      winston.error("(fbm) [FacebookClient] get user info err: ", err.response?.data || err.message);
+      // Return default user info to prevent undefined errors
+      return {
+        first_name: "User",
+        last_name: user_id
+      };
+    }
+  }
+
+  // HTTP REQUEST
+
+  static async myrequest(options, callback, log) {
+    
+    return await axios({
+      url: options.url,
+      method: options.method,
+      data: options.json,
+      params: options.params,
+      headers: options.headers
+    }).then((res) => {
+      if (res && res.status == 200 && res.data) {
+        if (callback) {
+          callback(null, res.data);
+        }
+      }
+      else {
+        if (callback) {
+          callback({ message: "Response status not 200", data: res.data }, null, null);
+        }
+      }
+    }).catch((err) => {
+      winston.error("(fbm) [FacebookClient] An error occured: ", err);
+      if (callback) {
+        callback(err, null, null);
+      }
+    })
+  }
+  
+}
+
+module.exports = { FacebookClient }

package/aimanager/KVBaseMongo.js

@@ -0,0 +1,99 @@
+const mongodb = require("mongodb");
+const winston = require('../winston');
+
+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.verbose("KV_COLLECTION: " + this.KV_COLLECTION)
+  }
+
+  connect(MONGODB_URI, callback) {
+    mongodb.MongoClient.connect(MONGODB_URI, { useNewUrlParser: true, useUnifiedTopology: true }, (err, client) => {
+      if (err) {
+        winston.log(err);
+        process.exit(1);
+      } else {
+        this.db = client.db();
+        this.db.collection(this.KV_COLLECTION).createIndex(
+          { "key": 1 }, { unique: true }
+        );
+        callback();
+      }
+    });
+  }
+
+  reuseConnection(db, callback) {
+    this.db = db;
+    this.db.collection(this.KV_COLLECTION).createIndex(
+      { "key": 1 }, { unique: true }
+    )
+    callback();
+  }
+  
+  set(k, v) {
+    return new Promise((resolve, reject) => {
+      //this.db.set(k, v).then(() => {resolve();});
+      this.db.collection(this.KV_COLLECTION).updateOne({key: k}, { $set: { value: v, key: k } }, { upsert: true }, function(err, doc) {
+        if (err) {
+          reject(err);
+        }
+        else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  get(k) {
+    return new Promise((resolve, reject) => {
+      //this.db.get(k).then(value => {resolve(value)});
+      winston.debug("Searching on " + this.db)
+      winston.verbose("Searching on Collection" + this.KV_COLLECTION)
+      
+      this.db.collection(this.KV_COLLECTION).findOne({ key: k }, function(err, doc) {
+        if (err) {
+          winston.error("Error reading mongodb value" + err);
+          reject(err);
+        }
+        else {
+          if (doc) {
+            winston.verbose("Doc found with key: " + doc.key);
+            resolve(doc.value);
+          }
+          else {
+            winston.verbose("No Doc found!");
+            resolve(null);
+          }
+        }
+      });
+    });
+  }
+
+  remove(k) {
+    return new Promise((resolve, reject) => {
+      this.db.collection(this.KV_COLLECTION).deleteOne({key: k}, function(err) {
+        if (err) {
+          reject(err);
+        }
+        else {
+          resolve();
+        }
+      });
+    });
+  }
+}
+
+module.exports = { KVBaseMongo };

package/aimanager/MessageHandler.js

@@ -0,0 +1,138 @@
+const axios = require("axios").default;
+const jwt = require('jsonwebtoken');
+const { v4: uuidv4 } = require('uuid');
+const winston = require('../winston');
+
+class MessageHandler {
+
+  /**
+    * Constructor for TiledeskChannel
+    *
+    * @example
+    * const { TiledeskChannel } = require('tiledesk-channel');
+    * const tdChannel = new TiledeskChannel({tiledeskJsonMessage: replyFromWhatsapp, settings: appSettings, whatsappJsonMessage: originalWhatsappMessage, API_URL: tiledeskApiUrl });
+    * 
+    * @param {Object} config JSON configuration.
+    * @param {string} config.tiledeskJsonMessage Mandatory. Message translated from Whatsapp to Tiledesk
+    * @param {string} config.whatsappJsonMessage Mandatory. Original whatsapp message.
+    * @param {string} config.settings Mandatory. Installation settings.
+    * @param {string} config.API_URL Mandatory. Tiledesk api url.
+    * @param {boolean} options.log Optional. If true HTTP requests are logged.
+    */
+  
+  constructor(config) {
+
+    /*
+    if (!config) {
+      throw new Error('config is mandatory');
+    }
+
+    if (!config.tiledeskChannelMessage) {
+      throw new Error('config.tiledeskChannelMessage is mandatory');
+    }
+    */
+
+    if (config) {
+      if (config.tiledeskChannelMessage) {
+        this.tiledeskChannelMessage = config.tiledeskChannelMessage;
+      } else {
+        winston.verbose("Missing config.tiledeskChannelMessage")
+      }
+    }
+    
+    this.log = false;
+
+  }
+
+  async generateMessageObject(command) {
+    winston.debug("(fbm) [MessageHandler] command: ", command);
+
+    let tiledeskCommandMessage = command.message;
+    tiledeskCommandMessage.recipient = this.tiledeskChannelMessage.recipient;
+    
+    return tiledeskCommandMessage;
+  }
+
+  async splitMessageFromTiledesk(tiledeskMessage) {
+
+    winston.debug("(fbm) [MessageHandler] split message tiledeskMessage: ", tiledeskMessage);
+    
+    return new Promise((resolve, reject) => {
+
+      let messagesList = [];
+
+      if (tiledeskMessage.metadata) {
+        let message = Object.assign({}, tiledeskMessage);
+        delete message.text;       
+
+        messagesList.push(message)
+
+        if (tiledeskMessage.text != null && tiledeskMessage.text != "") {
+          message = Object.assign({}, tiledeskMessage);
+          delete message.metadata;
+          message.type = "text";
+
+          messagesList.push(message);
+          resolve(messagesList);
+        } else {
+          resolve(messagesList);
+        }
+      } else {
+        messagesList.push(tiledeskMessage);
+        resolve(messagesList);
+      }
+      
+    })
+  }
+
+  async splitMessageFromInstagram(instagramMessage) {
+
+    winston.debug("(fbm) [MessageHandler] split message instagramMessage: ", instagramMessage);
+    
+    let messagesList = [];
+    return new Promise((resolve, reject) => {
+
+      let attachments = instagramMessage.message.attachments;
+      attachments.forEach((attachment) => {
+        let message = JSON.parse(JSON.stringify(instagramMessage));
+        delete message.message.attachments;
+        message.message.attachments = [ attachment ];
+
+        messagesList.push(message);
+      })
+      resolve(messagesList);
+      
+    })
+  }
+  
+
+  /*
+  generateMessageObjectOriginal(command_message) {
+      let parentUid = this.tiledeskChannelMessage.uid
+      //command_message.uid = this.tiledeskChannelMessage.uid + "_" + index;
+      command_message.uid = this.tiledeskChannelMessage.uid;
+      if(command_message.text) command_message.text = command_message.text.trim()//remove black msg with only spaces
+      command_message.language = message.language;
+      command_message.recipient = message.recipient;
+      command_message.recipient_fullname = message.recipient_fullname;
+      command_message.sender = message.sender;
+      command_message.sender_fullname = message.sender_fullname;
+      command_message.channel_type = message.channel_type;
+      command_message.status = message.status;
+      command_message.isSender = message.isSender;
+      command_message.attributes? command_message.attributes.commands = true : command_message.attributes = {commands : true}
+      command_message.attributes.parentUid = parentUid //added to manage message STATUS UPDATES
+      command_message.attributes = {...message.attributes, ...command_message.attributes}
+      //this.addedNew(command_message)
+      //callback();
+
+    return command_message
+  }
+  */
+
+  
+
+}
+
+module.exports = { MessageHandler }
+

package/aimanager/TiledeskAppsClient.js

@@ -0,0 +1,158 @@
+const axios = require("axios").default;
+const fs = require('fs');
+const FormData = require('form-data');
+const path = require('path');
+const winston = require('../winston');
+
+class TiledeskAppsClient {
+  /**
+    * Constructor for TiledeskChannel
+    *
+    * @example
+    * const { TiledeskAppsClient } = require('tiledesk-apps-client');
+    * const appClient = new TiledeskAppsClient({ APPS_API_URL:  APPS_API_URL});
+    * 
+    * @param {Object} config JSON configuration.
+    * @param {string} config.APPS_API_URL Mandatory. The api url for tiledesk apps.
+    * @param {boolean} options.log Optional. If true HTTP requests are logged.
+    */
+
+  constructor(config) {
+    if (!config) {
+      throw new Error('config is mandatory');
+    }
+
+    if (!config.APPS_API_URL) {
+      throw new Error('config.APPS_URL is mandatory');
+    }
+
+    this.APPS_API_URL = config.APPS_API_URL;
+  }
+
+
+  install(installation_info, callback) {
+    
+    const URL = this.APPS_API_URL + `/api/installation`;
+    const HTTPREQUEST = {
+      url: URL,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      json: installation_info,
+      method: 'POST'
+    };
+    let promise = new Promise((resolve, reject) => {
+      TiledeskAppsClient.myrequest(
+        HTTPREQUEST,
+        function(err, resbody) {
+          if (err) {
+            if (callback) {
+              callback(err);
+            }
+            reject(err);
+          }
+          else {
+            if (callback) {
+              callback(null, resbody);
+            }
+            winston.verbose("(fbm) [TiledeskAppsClient] Installed!");
+            resolve(resbody);
+          }
+        }, true);
+    })
+    return promise;
+  }
+
+  getInstallations(project_id, app_id) {
+    const URL = this.APPS_API_URL + `/api/installation/${project_id}`;
+    const HTTPREQUEST = {
+      url: URL,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      method: 'GET'
+    };
+    let promise = new Promise((resolve, reject) => {
+      TiledeskAppsClient.myrequest(
+        HTTPREQUEST,
+        function(err, resbody) {
+          if (err) {
+            reject(err);
+          }
+          else {
+            let obj = resbody.find(o => o.app_id === app_id);
+            if (obj) {
+              resolve(obj);
+            } else {
+              resolve(null);
+            }
+          }
+        }, true);
+    })
+    return promise;
+  }
+  
+  uninstall(project_id, app_id, callback) {
+    const URL = this.APPS_API_URL + `/api/installation/${project_id}/${app_id}`;
+    const HTTPREQUEST = {
+      url: URL,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      method: 'DELETE'
+    };
+    let promise = new Promise((resolve, reject) => {
+      TiledeskAppsClient.myrequest(
+        HTTPREQUEST,
+        function(err, resbody) {
+          if (err) {
+            if (callback) {
+              callback(err);
+            }
+            reject(err);
+          }
+          else {
+            if (callback) {
+              callback(null, resbody);
+            }
+            winston.verbose("(fbm) [TiledeskAppsClient] Uninstalled!");
+            resolve(resbody);
+          }
+        }, true);
+    })
+    return promise;
+  }
+
+
+
+  // HTTP REQUEST
+
+  static async myrequest(options, callback, log) {
+    return await axios({
+      url: options.url,
+      method: options.method,
+      data: options.json,
+      params: options.params,
+      headers: options.headers
+    }).then((res) => {
+      if (res && res.status == 200 && res.data) {
+        if (callback) {
+          callback(null, res.data);
+        }
+      }
+      else {
+        if (callback) {
+          callback(TiledeskClient.getErr({ message: "Response status not 200" }, options, res), null, null);
+        }
+      }
+    }).catch((err) => {
+      winston.error("(fbm) [TiledeskAppsClient] An error occured: ", err);
+      if (callback) {
+        callback(err, null, null);
+      }
+    })
+  }
+  
+}
+
+module.exports = { TiledeskAppsClient }