@tiledesk/tiledesk-server 2.28.2 → 2.29.0

package/CHANGELOG.md

@@ -5,6 +5,10 @@
 🚀        IN PRODUCTION                        🚀
 (https://www.npmjs.com/package/@tiledesk/tiledesk-server/v/2.3.77) 
 
+# 2.29.0
+- Added support Subagents
+- Bumped tybot-connector version to 2.3.0
+
 # 2.28.2
 - Bumped whatsapp-connector version to 1.0.31: broadcast jobs are published on a single shared AMQP connection instead of opening a new one per request.
 - Bumped whatsapp-jobworker version to 0.0.14: the broadcast consumer now recovers after failed reconnections, closed channels and consumer cancellations, always acks the jobs and uses a timeout for the WhatsApp Graph API calls.

package/app.js

@@ -29,9 +29,11 @@ var cors = require('cors');
 var Project = require("./models/project");
 var validtoken = require('./middleware/valid-token');
 var roleChecker = require('./middleware/has-role');
+var errorHandler = require('./middleware/errorHandler');
 
 const MaskData = require("maskdata");
 var winston = require('./config/winston');
+var pjson = require('./package.json');
 
 
 // DATABASE CONNECTION
@@ -458,7 +460,7 @@ if (process.env.ROUTELOGGER_ENABLED==="true") {
 }
 
 app.get('/', function (req, res) {
-  res.send('Hello from Tiledesk server. It\'s UP. See the documentation here http://developer.tiledesk.com');
+  res.send('Tiledesk Server version: ' + pjson.version + ' is UP. See the documentation here http://developer.tiledesk.com');
 });
   
 
@@ -698,39 +700,8 @@ app.use(function (err, req, res, next) {
 
 // mettere middleware qui per le quote
 
-
-
-// error handler
-app.use((err, req, res, next) => {
-
-  winston.debug("err.name", err.name)
-  if (err.name === "IpDeniedError") {
-    winston.debug("IpDeniedError");
-    return res.status(401).json({ err: "error ip filter" });
-  }
-
-  const realIp = req.headers['x-forwarded-for']?.split(',')[0] || req.headers['x-real-ip'] || req.ip;
-
-  //emitted by multer when the file is too big
-  if (err.code === "LIMIT_FILE_SIZE") {
-    winston.debug("LIMIT_FILE_SIZE");
-    winston.warn(`LIMIT_FILE_SIZE on ${req.originalUrl}`, {
-      limit: process.env.MAX_UPLOAD_FILE_SIZE,
-      ip: req.ip,
-      realIp: realIp
-    });
-    return res.status(413).json({ err: "Content Too Large", limit_file_size: process.env.MAX_UPLOAD_FILE_SIZE });
-  }
-  
-  if (err.type === "entity.too.large" || err.name === "PayloadTooLargeError") {
-    winston.warn("Payload too large", { expected: err.expected, limit: err.limit, length: err.length });
-    return res.status(413).json({ err: "Request entity too large", limit: err.limit});
-  }
-
-
-  winston.error("General error: ", err);
-  return res.status(500).json({ err: "error" });
-});
+// error handler (must be registered last)
+app.use(errorHandler);
 
 
 module.exports = app;

package/controllers/chatbot.controller.js

@@ -0,0 +1,599 @@
+const Chatbot = require("../models/faq_kb");
+const Faq = require("../models/faq");
+const faqService = require("../services/faqService");
+const AppError = require("../utils/AppError");
+const intentsController = require("./intents.controller");
+const botEvent = require("../event/botEvent");
+const winston = require("../config/winston");
+
+const IMPORT_OVERRIDE_FIELDS = [
+  "webhook_enabled",
+  "webhook_url",
+  "language",
+  "name",
+  "description",
+  "type",
+  "subtype"
+];
+
+class ChatbotController {
+
+  constructor() { }
+
+  canAccess(chatbot, id_project) {
+    const isPublic = chatbot.public === true;
+    const isOwner = chatbot.id_project === id_project;
+    if (!isPublic && !isOwner) {
+      return false
+    }
+    return true;
+  }
+
+  _sanitizeIntent(intent) {
+    const {
+      _id, id_project, id_faq_kb, topic, status, chatbot_id,
+      createdBy, createdAt, updatedAt, __v, ...keepAttrs
+    } = intent;
+    return keepAttrs;
+  }
+
+  _sanitizeSubagent(subagent) {
+    return {
+      // Keep source _id so import can remap intents.actions[].botId
+      // to the newly created subagent. It is stripped before insert.
+      _id: subagent._id ? subagent._id.toString() : undefined,
+      webhook_enabled: subagent.webhook_enabled,
+      webhook_url: subagent.webhook_url,
+      language: subagent.language,
+      name: subagent.name,
+      slug: subagent.slug,
+      type: subagent.type,
+      subtype: subagent.subtype,
+      description: subagent.description,
+      attributes: subagent.attributes,
+      intents: (subagent.intents || []).map((intent) => this._sanitizeIntent(intent))
+    };
+  }
+
+  export(chatbot, intents, intentsOnly, subagents) {
+    const sanitizedIntents = (intents || []).map((intent) => this._sanitizeIntent(intent));
+
+    if (intentsOnly) {
+      return JSON.stringify({ intents: sanitizedIntents });
+    }
+
+    return JSON.stringify({
+      webhook_enabled: chatbot.webhook_enabled,
+      webhook_url: chatbot.webhook_url,
+      language: chatbot.language,
+      name: chatbot.name,
+      slug: chatbot.slug,
+      type: chatbot.type,
+      subtype: chatbot.subtype,
+      description: chatbot.description,
+      attributes: chatbot.attributes,
+      parent_id: chatbot.parent_id,
+      intents: sanitizedIntents,
+      subagents: (subagents || []).map((subagent) => this._sanitizeSubagent(subagent))
+    })
+  }
+
+  _rewriteRulesParticipants(attributes, chatbot_id) {
+    if (!attributes?.rules?.length) {
+      return attributes;
+    }
+    for (const rule of attributes.rules) {
+      if (rule.do?.[0]?.message?.participants?.[0]) {
+        rule.do[0].message.participants[0] = "bot_" + chatbot_id;
+      }
+    }
+    return attributes;
+  }
+
+  _sourceId(doc) {
+    if (!doc || doc._id == null) {
+      return null;
+    }
+    return doc._id.toString();
+  }
+
+  _stripImportedIdentity(doc) {
+    if (!doc) {
+      return;
+    }
+    delete doc._id;
+    delete doc.id_project;
+    delete doc.createdBy;
+    delete doc.createdAt;
+    delete doc.updatedAt;
+    delete doc.__v;
+  }
+
+  _collectBotIds(value, botIds = new Set()) {
+    if (!value) {
+      return botIds;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((item) => this._collectBotIds(item, botIds));
+      return botIds;
+    }
+    if (typeof value !== "object") {
+      return botIds;
+    }
+    if (value.botId != null) {
+      botIds.add(value.botId.toString());
+    }
+    Object.keys(value).forEach((key) => {
+      if (key === "botId") {
+        return;
+      }
+      this._collectBotIds(value[key], botIds);
+    });
+    return botIds;
+  }
+
+  _mappedBotId(botId, idMap) {
+    if (botId == null || !idMap) {
+      return null;
+    }
+    const raw = botId.toString();
+    if (idMap[raw]) {
+      return idMap[raw];
+    }
+    if (raw.startsWith("bot_")) {
+      const mapped = idMap[raw.slice(4)];
+      if (mapped) {
+        return "bot_" + mapped;
+      }
+    }
+    return null;
+  }
+
+  _rewriteBotIdsInValue(value, idMap) {
+    if (!value || !idMap) {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((item) => this._rewriteBotIdsInValue(item, idMap));
+      return value;
+    }
+    if (typeof value !== "object") {
+      return value;
+    }
+    if (value.botId != null) {
+      const mapped = this._mappedBotId(value.botId, idMap);
+      if (mapped) {
+        value.botId = mapped;
+      }
+    }
+    Object.keys(value).forEach((key) => {
+      if (key === "botId") {
+        return;
+      }
+      this._rewriteBotIdsInValue(value[key], idMap);
+    });
+    return value;
+  }
+
+  _rewriteBotIdsInIntents(intents, idMap) {
+    (intents || []).forEach((intent) => {
+      this._rewriteBotIdsInValue(intent.actions, idMap);
+      this._rewriteBotIdsInValue(intent.attributes, idMap);
+    });
+  }
+
+  async _fillBotIdMapFromSourceBots(intents, idMap, nameMap) {
+    const botIds = this._collectBotIds(intents);
+    for (const botId of botIds) {
+      const lookupId = botId.startsWith("bot_") ? botId.slice(4) : botId;
+      if (idMap[lookupId] || idMap[botId]) {
+        continue;
+      }
+      try {
+        const sourceBot = await Chatbot.findById(lookupId).lean();
+        if (sourceBot?.name && nameMap[sourceBot.name]) {
+          idMap[lookupId] = nameMap[sourceBot.name];
+        }
+      } catch (err) {
+        winston.debug("(ChatbotController) skip botId remap for " + botId);
+      }
+    }
+  }
+
+  _buildSubagentPayload(subagentJson, parent_id, id_project) {
+    this._stripImportedIdentity(subagentJson);
+    return {
+      name: subagentJson.name,
+      description: subagentJson.description,
+      type: subagentJson.type || "tilebot",
+      subtype: "subagent",
+      language: subagentJson.language,
+      webhook_url: subagentJson.webhook_url,
+      webhook_enabled: subagentJson.webhook_enabled,
+      attributes: subagentJson.attributes,
+      parent_id: parent_id.toString(),
+      id_project: id_project.toString(),
+      template: "empty"
+    };
+  }
+
+  async findSubagents(chatbot_id, id_project, select) {
+    try {
+      let query = Chatbot.find({
+        id_project: id_project,
+        parent_id: chatbot_id,
+        trashed: { $in: [null, false] }
+      });
+      if (select) {
+        query = query.select(select);
+      } else {
+        query = query.sort({ createdAt: -1 });
+      }
+      return await query.lean().exec();
+    } catch (err) {
+      winston.error("(ChatbotController) findSubagents error: ", err);
+      throw new AppError(500, `Error finding subagents with id ${chatbot_id}`);
+    }
+
+  }
+
+  async findSubagentCaller(chatbot, id_project) {
+    if (!chatbot || !chatbot.parent_id) {
+      return null;
+    }
+
+    const chatbotId = chatbot._id.toString();
+    const parentId = chatbot.parent_id.toString();
+
+    let siblingIds;
+    try {
+      siblingIds = await Chatbot.find({
+        id_project: id_project,
+        parent_id: parentId,
+        _id: { $ne: chatbot._id }
+      }).select('_id').lean();
+    } catch (err) {
+      winston.error("(ChatbotController) findSubagentCaller error getting siblings: ", err);
+      throw new AppError(500, "Error checking subagent references");
+    }
+
+    const relatedIds = [parentId, ...siblingIds.map((bot) => bot._id.toString())];
+
+    const filter = {
+      id_project: id_project,
+      id_faq_kb: { $in: relatedIds },
+      $or: [{ 'actions.botId': chatbotId }]
+    };
+    if (chatbot.slug) {
+      filter.$or.push({ 'actions.botSlug': chatbot.slug });
+    }
+
+    try {
+      return await Faq.findOne(filter)
+        .select('_id id_faq_kb intent_display_name')
+        .lean();
+    } catch (err) {
+      winston.error("(ChatbotController) findSubagentCaller error: ", err);
+      throw new AppError(500, "Error checking subagent references");
+    }
+  }
+
+  async deleteSubagents(parent_id, id_project) {
+    const subagents = await this.findSubagents(parent_id, id_project, '_id');
+    await Promise.all(subagents.map(async (subagent) => {
+      await intentsController.deleteByChatbotId(subagent._id);
+      await Chatbot.deleteOne({ _id: subagent._id, id_project: id_project });
+    }));
+  }
+
+  async assertAreSubagents(id_project, parent_id, chatbot_ids) {
+    const parentId = parent_id.toString();
+    const idsToCheck = [...new Set(
+      (chatbot_ids || [])
+        .map((id) => (id == null ? '' : id.toString().trim()))
+        .filter((id) => id && id !== parentId)
+    )];
+
+    if (!idsToCheck.length) {
+      return true;
+    }
+
+    const subagents = await this.findSubagents(parent_id, id_project, '_id');
+    const foundSet = new Set(subagents.map((bot) => bot._id.toString()));
+    const invalid = idsToCheck.filter((id) => !foundSet.has(id));
+    if (invalid.length > 0) {
+      throw new AppError(400, `Subagent IDs are not valid: ${invalid.join(", ")}`);
+    }
+
+    return true;
+  }
+  
+  async getChatbot(chatbot_id, id_project) {
+    let chatbot;
+    try {
+      chatbot = await Chatbot.findOne({ _id: chatbot_id, id_project: id_project });
+    } catch (err) {
+      winston.error("(ChatbotController) getChatbot error: ", err);
+      throw new AppError(500, `Error finding chatbot with id ${chatbot_id}`);
+    }
+    if (!chatbot) {
+      throw new AppError(404, `Chatbot not found with id ${chatbot_id} for project ${id_project}`);
+    }
+    return chatbot;
+  }
+
+  async getChatbotById(chatbot_id) {
+    let chatbot;
+    try {
+      chatbot = await Chatbot.findById(chatbot_id);
+    } catch (err) {
+      winston.error("(ChatbotController) getChatbotById error: ", err);
+      throw new AppError(500, `Error finding chatbot with id ${chatbot_id}`);
+    }
+    if (!chatbot) {
+      throw new AppError(404, `Chatbot not found with id ${chatbot_id}`);
+    }
+    return chatbot;
+  }
+
+  async _importIntents(chatbot_id, id_project, user_id, intents, overwrite) {
+    if (!intents?.length) {
+      return;
+    }
+    if (overwrite) {
+      await intentsController.upsertMany(chatbot_id, id_project, user_id, intents);
+    } else {
+      await intentsController.createMany(
+        chatbot_id,
+        id_project,
+        user_id,
+        intents,
+        { skipDuplicates: true }
+      );
+    }
+  }
+
+  async _createSubagent(id_project, user_id, payload) {
+    let subagent;
+    try {
+      subagent = await faqService.create(id_project, user_id, payload);
+    } catch (err) {
+      winston.error("(ChatbotController) create subagent error: ", err);
+      throw new AppError(400, "Error creating subagent");
+    }
+
+    if (payload.attributes) {
+      this._rewriteRulesParticipants(payload.attributes, subagent._id);
+      subagent = await this.updatedChatbot(subagent._id, id_project, { attributes: payload.attributes });
+    }
+
+    return subagent;
+  }
+
+  async _updateSubagent(subagent, payload, id_project) {
+    subagent.id_project = id_project.toString();
+    for (const field of IMPORT_OVERRIDE_FIELDS) {
+      if (payload[field] !== undefined && payload[field] !== null) {
+        subagent[field] = payload[field];
+      }
+    }
+
+    if (payload.attributes) {
+      this._rewriteRulesParticipants(payload.attributes, subagent._id);
+      subagent.attributes = payload.attributes;
+    }
+
+    try {
+      subagent = await Chatbot.findByIdAndUpdate(subagent._id, subagent, { new: true });
+    } catch (err) {
+      winston.error("(ChatbotController) update subagent error: ", err);
+      throw new AppError(400, "Error updating subagent");
+    }
+
+    botEvent.emit("faqbot.update", subagent);
+    return subagent;
+  }
+
+  async _importSubagents(parent, subagentsJson, id_project, user_id, replace, overwrite, idMap, nameMap) {
+    if (replace) {
+      await this.deleteSubagents(parent._id, id_project);
+    }
+
+    const imported = [];
+    if (!subagentsJson?.length) {
+      return imported;
+    }
+
+    for (const subagentJson of subagentsJson) {
+      const sourceId = this._sourceId(subagentJson);
+      const payload = this._buildSubagentPayload(subagentJson, parent._id, id_project);
+      let subagent = await Chatbot.findOne({
+        id_project: id_project,
+        parent_id: parent._id.toString(),
+        name: subagentJson.name
+      });
+
+      if (overwrite) {
+        if (subagent) {
+          subagent = await this._updateSubagent(subagent, payload, id_project);
+        } else {
+          subagent = await this._createSubagent(id_project, user_id, payload);
+        }
+      } else if (!subagent) {
+        subagent = await this._createSubagent(id_project, user_id, payload);
+      } else {
+        winston.debug("Skip existing subagent with name: " + subagentJson.name);
+      }
+
+      if (subagent) {
+        const newId = subagent._id.toString();
+        if (sourceId) {
+          idMap[sourceId] = newId;
+        }
+        if (subagent.name) {
+          nameMap[subagent.name] = newId;
+        }
+        imported.push({ subagent, intents: subagentJson.intents });
+      }
+    }
+    return imported;
+  }
+
+  async _remapImportedBotIds(json, importedSubagents, idMap, nameMap, keepExternalBotIds) {
+    if (!keepExternalBotIds) {
+      const allIntents = [
+        ...(json.intents || []),
+        ...importedSubagents.flatMap((item) => item.intents || [])
+      ];
+      await this._fillBotIdMapFromSourceBots(allIntents, idMap, nameMap);
+    }
+    this._rewriteBotIdsInIntents(json.intents, idMap);
+    importedSubagents.forEach((item) => {
+      this._rewriteBotIdsInIntents(item.intents, idMap);
+    });
+  }
+
+  async import(json, id_project, chatbot_id, create, replace, overwrite, user_id, skipSubagents) {
+    let chatbot;
+    const sourceParentId = this._sourceId(json);
+    this._stripImportedIdentity(json);
+
+    if (create) {
+      json.template = "empty";
+      try {
+        chatbot = await faqService.create(id_project, user_id, json);
+      } catch (err) {
+        winston.error("(ChatbotController) import create error: ", err);
+        throw new AppError(400, "Error creating new chatbot");
+      }
+
+      if (json.attributes) {
+        this._rewriteRulesParticipants(json.attributes, chatbot._id);
+        chatbot = await this.updatedChatbot(chatbot._id, id_project, { attributes: json.attributes });
+      }
+    } else {
+      if (!chatbot_id) {
+        throw new AppError(400, "With replace or overwrite option a id_faq_kb must be provided");
+      }
+
+      chatbot = await this.getChatbot(chatbot_id, id_project);
+
+      for (const field of IMPORT_OVERRIDE_FIELDS) {
+        if (json[field]) {
+          chatbot[field] = json[field];
+        }
+      }
+
+      if (json.attributes) {
+        this._rewriteRulesParticipants(json.attributes, chatbot._id);
+        chatbot.attributes = json.attributes;
+      }
+
+      try {
+        chatbot = await Chatbot.findByIdAndUpdate(chatbot._id, chatbot, { new: true });
+      } catch (err) {
+        winston.error("(ChatbotController) import update error: ", err);
+        throw new AppError(400, "Error updating chatbot");
+      }
+      if (!chatbot) {
+        throw new AppError(404, `Chatbot not found with id ${chatbot_id}`);
+      }
+
+      botEvent.emit("faqbot.update", chatbot);
+    }
+
+    if (replace) {
+      await intentsController.deleteByChatbotId(chatbot._id);
+    }
+
+    const idMap = {};
+    const nameMap = {};
+    if (sourceParentId) {
+      idMap[sourceParentId] = chatbot._id.toString();
+    }
+    if (chatbot.name) {
+      nameMap[chatbot.name] = chatbot._id.toString();
+    }
+
+    let importedSubagents = [];
+    if (!skipSubagents) {
+      importedSubagents = await this._importSubagents(
+        chatbot,
+        json.subagents,
+        id_project,
+        user_id,
+        replace,
+        overwrite,
+        idMap,
+        nameMap
+      );
+    }
+    await this._remapImportedBotIds(json, importedSubagents, idMap, nameMap, skipSubagents);
+
+    await this._importIntents(chatbot._id, id_project, user_id, json.intents, overwrite);
+    await Promise.all(importedSubagents.map((item) =>
+      this._importIntents(item.subagent._id, id_project, user_id, item.intents, overwrite)
+    ));
+
+    return chatbot;
+  }
+
+  async _exportJson(chatbot, id_project, { exportGlobals = false } = {}) {
+    const chatbotData = chatbot.toObject ? chatbot.toObject() : { ...chatbot };
+    if (!exportGlobals && chatbotData.attributes) {
+      chatbotData.attributes = { ...chatbotData.attributes };
+      delete chatbotData.attributes.globals;
+    }
+
+    const intents = await intentsController.getIntents(chatbot._id);
+    const subagents = await this.findSubagents(chatbot._id, id_project);
+    await Promise.all(subagents.map(async (subagent) => {
+      subagent.intents = await intentsController.getIntents(subagent._id);
+    }));
+
+    const json = JSON.parse(this.export(chatbotData, intents, false, subagents));
+    json._id = chatbot._id.toString();
+    return json;
+  }
+
+  async restoreFromPublished(draft_id, publish_id, id_project, user_id) {
+    const draft = await this.getChatbot(draft_id, id_project);
+    if (draft.root_id) {
+      throw new AppError(400, "Cannot restore into a published chatbot");
+    }
+
+    const published = await this.getChatbot(publish_id, id_project);
+    if (!published.root_id || published.root_id.toString() !== draft._id.toString()) {
+      throw new AppError(400, `Chatbot ${publish_id} is not a published version of ${draft_id}`);
+    }
+
+    const json = await this._exportJson(published, id_project);
+    if (draft.attributes?.globals) {
+      json.attributes = { ...(json.attributes || {}), globals: draft.attributes.globals };
+    }
+
+    // A publish snapshot has no cloned subagents. Restoring it must not delete the draft ones.
+    const skipSubagents = !json.subagents?.length;
+    const restored = await this.import(json, id_project, draft_id, false, true, false, user_id, skipSubagents);
+    return this.updatedChatbot(restored._id, id_project, { modified: true });
+  }
+
+  async updatedChatbot(chatbot_id, id_project, update) {
+    let chatbot;
+    try {
+      chatbot = await Chatbot.findOneAndUpdate({ _id: chatbot_id, id_project: id_project }, update, { new: true });
+    } catch (err) {
+      winston.error("(ChatbotController) updatedChatbot error: ", err);
+      throw new AppError(500, `Error updating chatbot with id ${chatbot_id}`);
+    }
+    if (!chatbot) {
+      throw new AppError(404, `Chatbot not found with id ${chatbot_id} for project ${id_project}`);
+    }
+    return chatbot;
+  }
+
+
+}
+
+const chatbotController = new ChatbotController();
+module.exports = chatbotController;