@tiledesk/tiledesk-server 2.23.0 → 2.24.1

package/services/requestService.js

@@ -22,10 +22,12 @@ const projectService = require('./projectService');
 const axios = require("axios").default;
 
 let port = process.env.PORT || '3000';
-let TILEBOT_ENDPOINT = "http://localhost:" + port + "/modules/tilebot/ext/";;
+let TILEBOT_ENDPOINT = process.env.API_ENDPOINT ? process.env.API_ENDPOINT + "/modules/tilebot/ext/" : ("http://localhost:" + port + "/modules/tilebot/ext/");
+
 if (process.env.TILEBOT_ENDPOINT) {
-    TILEBOT_ENDPOINT = process.env.TILEBOT_ENDPOINT + "/ext/"
+  TILEBOT_ENDPOINT = process.env.TILEBOT_ENDPOINT + "/ext/";
 }
+winston.info("[RequestService] TILEBOT_ENDPOINT: " + TILEBOT_ENDPOINT);
 
 let tdCache = new TdCache({
     host: process.env.CACHE_REDIS_HOST,

package/services/webhookService.js

@@ -7,11 +7,12 @@ const errorCodes = require("../errorCodes");
 var ObjectId = require('mongoose').Types.ObjectId;
 
 const port = process.env.PORT || '3000';
-let TILEBOT_ENDPOINT = "http://localhost:" + port + "/modules/tilebot/";;
+let TILEBOT_ENDPOINT = process.env.API_ENDPOINT ? process.env.API_ENDPOINT + "/modules/tilebot/ext/" : ("http://localhost:" + port + "/modules/tilebot/ext/");
+
 if (process.env.TILEBOT_ENDPOINT) {
-    TILEBOT_ENDPOINT = process.env.TILEBOT_ENDPOINT + "/"
+  TILEBOT_ENDPOINT = process.env.TILEBOT_ENDPOINT + "/ext/";
 }
-winston.debug("TILEBOT_ENDPOINT: " + TILEBOT_ENDPOINT);
+winston.info("[RequestService] TILEBOT_ENDPOINT: " + TILEBOT_ENDPOINT);
 
 class WebhookService {
 

package/test/authenticationJwt.js

@@ -20,6 +20,7 @@ var assert = chai.assert;
 var jwt = require('jsonwebtoken');
 var config = require('../config/database'); // get db config file
 var faqService = require('../services/faqService');
+var Subscription = require('../models/subscription');
 
 let log = false;
 
@@ -403,6 +404,125 @@ describe('AuthenticationJWT', () => {
         });
     });
 
+    it('subscriptionJwt-wildcard-id-project-can-access-specific-project', (done) => {
+
+        var email = "test-signup-" + Date.now() + "@email.com";
+        var pwd = "pwd";
+
+        userService.signup(email, pwd, "Test Firstname", "Test lastname").then(function (savedUser) {
+            projectService.create("test-sub-wildcard-project", savedUser._id).then(function (savedProject) {
+                var subscription = new Subscription({
+                    event: "queues.request.create." + Date.now(),
+                    target: "https://queues.example.com/hook",
+                    id_project: "*",
+                    createdBy: savedUser._id
+                });
+                subscription.save(function (err, savedSub) {
+                    if (err) { console.error("err: ", err); return done(err); }
+
+                    var signOptions = {
+                        subject: 'subscription',
+                        audience: 'https://tiledesk.com/subscriptions/' + savedSub._id,
+                    };
+                    var jwtToken = jwt.sign(savedSub.toObject(), savedSub.secret, signOptions);
+
+                    chai.request(server)
+                        .get('/' + savedProject._id + '/authtestWithRoleCheck/subscription')
+                        .set('Authorization', 'JWT ' + jwtToken)
+                        .send()
+                        .end((err, res) => {
+                            if (err) { console.error("err: ", err); }
+                            if (log) { console.log("res.body", res.body); }
+
+                            res.should.have.status(200);
+                            done();
+                        });
+                });
+            });
+        });
+    }).timeout(20000);
+
+    it('subscriptionJwt-global-true-can-access-specific-project', (done) => {
+
+        var email = "test-signup-" + Date.now() + "@email.com";
+        var pwd = "pwd";
+
+        userService.signup(email, pwd, "Test Firstname", "Test lastname").then(function (savedUser) {
+            projectService.create("test-sub-global-a", savedUser._id).then(function (projectA) {
+                projectService.create("test-sub-global-b", savedUser._id).then(function (projectB) {
+                    var subscription = new Subscription({
+                        event: "queues.global." + Date.now(),
+                        target: "https://queues.example.com/hook",
+                        id_project: projectA._id,
+                        global: true,
+                        createdBy: savedUser._id
+                    });
+                    subscription.save(function (err, savedSub) {
+                        if (err) { console.error("err: ", err); return done(err); }
+
+                        var signOptions = {
+                            subject: 'subscription',
+                            audience: 'https://tiledesk.com/subscriptions/' + savedSub._id,
+                        };
+                        var jwtToken = jwt.sign(savedSub.toObject(), savedSub.secret, signOptions);
+
+                        chai.request(server)
+                            .get('/' + projectB._id + '/authtestWithRoleCheck/subscription')
+                            .set('Authorization', 'JWT ' + jwtToken)
+                            .send()
+                            .end((err, res) => {
+                                if (err) { console.error("err: ", err); }
+                                if (log) { console.log("res.body", res.body); }
+
+                                res.should.have.status(200);
+                                done();
+                            });
+                    });
+                });
+            });
+        });
+    }).timeout(20000);
+
+    it('subscriptionJwt-denied-cross-project', (done) => {
+
+        var email = "test-signup-" + Date.now() + "@email.com";
+        var pwd = "pwd";
+
+        userService.signup(email, pwd, "Test Firstname", "Test lastname").then(function (savedUser) {
+            projectService.create("test-sub-project-a", savedUser._id).then(function (projectA) {
+                projectService.create("test-sub-project-b", savedUser._id).then(function (projectB) {
+                    var subscription = new Subscription({
+                        event: "webhook.request.create." + Date.now(),
+                        target: "https://hooks.example.com/hook",
+                        id_project: projectA._id,
+                        createdBy: savedUser._id
+                    });
+                    subscription.save(function (err, savedSub) {
+                        if (err) { console.error("err: ", err); return done(err); }
+
+                        var signOptions = {
+                            subject: 'subscription',
+                            audience: 'https://tiledesk.com/subscriptions/' + savedSub._id,
+                        };
+                        var jwtToken = jwt.sign(savedSub.toObject(), savedSub.secret, signOptions);
+
+                        chai.request(server)
+                            .get('/' + projectB._id + '/authtestWithRoleCheck/subscription')
+                            .set('Authorization', 'JWT ' + jwtToken)
+                            .send()
+                            .end((err, res) => {
+                                if (err) { console.error("err: ", err); }
+                                if (log) { console.log("res.body", res.body); }
+
+                                res.should.have.status(403);
+                                done();
+                            });
+                    });
+                });
+            });
+        });
+    }).timeout(20000);
+
     it('botJwt-denied-cross-project', (done) => {
 
         var email = "test-signup-" + Date.now() + "@email.com";

package/test/hasRole.js

@@ -0,0 +1,127 @@
+process.env.NODE_ENV = 'test';
+process.env.LOG_LEVEL = 'critical';
+
+const { expect } = require('chai');
+const roleChecker = require('../middleware/has-role');
+const Subscription = require('../models/subscription');
+const Faq_kb = require('../models/faq_kb');
+
+describe('RoleChecker.belongsToProject', () => {
+
+    const projectA = '6565047fdd64fd001323f37c';
+    const projectB = '507f1f77bcf86cd799439011';
+
+    it('fails closed when user, id_project or projectid is missing', () => {
+        expect(roleChecker.belongsToProject(null, projectA)).to.equal(false);
+        expect(roleChecker.belongsToProject({}, projectA)).to.equal(false);
+        expect(roleChecker.belongsToProject(new Subscription({ event: 'e', target: 't', createdBy: 'u' }), projectA)).to.equal(false);
+        expect(roleChecker.belongsToProject(new Subscription({ event: 'e', target: 't', id_project: projectA, createdBy: 'u' }), null)).to.equal(false);
+    });
+
+    it('allows a subscription with id_project "*" to access a specific projectid', () => {
+        const subscription = new Subscription({
+            event: 'request.create',
+            target: 'https://queues.example.com',
+            id_project: '*',
+            createdBy: 'queues'
+        });
+        expect(roleChecker.belongsToProject(subscription, projectA)).to.equal(true);
+    });
+
+    it('allows a subscription with global: true to access a specific projectid', () => {
+        const subscription = new Subscription({
+            event: 'request.create',
+            target: 'https://queues.example.com',
+            id_project: projectA,
+            global: true,
+            createdBy: 'queues'
+        });
+        expect(roleChecker.belongsToProject(subscription, projectB)).to.equal(true);
+    });
+
+    it('denies a subscription bound to project A from accessing project B', () => {
+        const subscription = new Subscription({
+            event: 'request.create',
+            target: 'https://hooks.example.com',
+            id_project: projectA,
+            createdBy: 'user1'
+        });
+        expect(roleChecker.belongsToProject(subscription, projectB)).to.equal(false);
+        expect(roleChecker.belongsToProject(subscription, projectA)).to.equal(true);
+    });
+
+    it('denies a bot for project A from accessing project B', () => {
+        const bot = new Faq_kb({
+            name: 'testbot',
+            id_project: projectA,
+            createdBy: 'user1'
+        });
+        expect(roleChecker.belongsToProject(bot, projectB)).to.equal(false);
+        expect(roleChecker.belongsToProject(bot, projectA)).to.equal(true);
+    });
+
+    it('does not give bots a wildcard even if id_project is "*" or global is true', () => {
+        const wildcardBot = new Faq_kb({
+            name: 'wildcard-bot',
+            id_project: '*',
+            createdBy: 'user1'
+        });
+        expect(roleChecker.belongsToProject(wildcardBot, projectA)).to.equal(false);
+
+        const globalBot = new Faq_kb({
+            name: 'global-bot',
+            id_project: projectA,
+            createdBy: 'user1'
+        });
+        globalBot.set('global', true);
+        expect(roleChecker.belongsToProject(globalBot, projectB)).to.equal(false);
+    });
+});
+
+describe('RoleChecker.isTypeAsFunction', () => {
+
+    const projectA = '6565047fdd64fd001323f37c';
+    const projectB = '507f1f77bcf86cd799439011';
+
+    it('allows a subscription with id_project "*" to access a specific projectid', () => {
+        const subscription = new Subscription({
+            event: 'request.create',
+            target: 'https://queues.example.com',
+            id_project: '*',
+            createdBy: 'queues'
+        });
+        expect(roleChecker.isTypeAsFunction('subscription', subscription, projectA)).to.equal(true);
+    });
+
+    it('allows a subscription with global: true to access a specific projectid', () => {
+        const subscription = new Subscription({
+            event: 'request.create',
+            target: 'https://queues.example.com',
+            id_project: projectA,
+            global: true,
+            createdBy: 'queues'
+        });
+        expect(roleChecker.isTypeAsFunction('subscription', subscription, projectB)).to.equal(true);
+    });
+
+    it('denies a subscription bound to project A from accessing project B', () => {
+        const subscription = new Subscription({
+            event: 'request.create',
+            target: 'https://hooks.example.com',
+            id_project: projectA,
+            createdBy: 'user1'
+        });
+        expect(roleChecker.isTypeAsFunction('subscription', subscription, projectB)).to.equal(false);
+        expect(roleChecker.isTypeAsFunction('subscription', subscription, projectA)).to.equal(true);
+    });
+
+    it('denies a bot for project A from accessing project B', () => {
+        const bot = new Faq_kb({
+            name: 'testbot',
+            id_project: projectA,
+            createdBy: 'user1'
+        });
+        expect(roleChecker.isTypeAsFunction('bot', bot, projectB)).to.equal(false);
+        expect(roleChecker.isTypeAsFunction('bot', bot, projectA)).to.equal(true);
+    });
+});

package/test/nativemcp.test.js

@@ -0,0 +1,167 @@
+//During the test the env variable is set to test
+process.env.NODE_ENV = 'test';
+
+const projectService = require('../services/projectService');
+const userService = require('../services/userService');
+
+//Require the dev-dependencies
+let chai = require('chai');
+let chaiHttp = require('chai-http');
+let server = require('../app');
+let should = chai.should();
+const expect = chai.expect;
+
+let log = false;
+
+chai.use(chaiHttp);
+
+function createProjectUser(done, callback) {
+  const email = "test-signup-" + Date.now() + "@email.com";
+  const pwd = "pwd";
+
+  userService.signup(email, pwd, "Test Firstname", "Test Lastname").then((savedUser) => {
+    projectService.create("test-native-mcp", savedUser._id).then((savedProject) => {
+      callback(savedProject, email, pwd, done);
+    });
+  });
+}
+
+describe('NativeMCP', () => {
+
+  it('get-native-mcp-servers-list', (done) => {
+    createProjectUser(done, (savedProject, email, pwd, done) => {
+      chai.request(server)
+        .get('/' + savedProject._id + '/mcp/native')
+        .auth(email, pwd)
+        .end((err, res) => {
+          
+          if (err) { console.error("err: ", err); }
+          if (log) { console.log("res.body: ", res.body); }
+
+          res.should.have.status(200);
+          res.body.should.be.an('array');
+          res.body.should.have.length(2);
+
+          expect(res.body[0].id).to.equal("tiledesk-communicator");
+          expect(res.body[0].name).to.equal("Tiledesk Communicator");
+          expect(res.body[0].native).to.equal(true);
+          expect(res.body[0].transport).to.equal("streamable_http");
+          expect(res.body[0].url).to.not.exist;
+          expect(res.body[1].id).to.equal("tiledesk-data-table");
+          expect(res.body[1].name).to.equal("Tiledesk Data Table");
+          expect(res.body[1].native).to.equal(true);
+          expect(res.body[1].transport).to.equal("streamable_http");
+          expect(res.body[1].url).to.not.exist;
+
+          done();
+        });
+    });
+  });
+
+  it('connect-native-mcp-server-not-found', (done) => {
+    createProjectUser(done, (savedProject, email, pwd, done) => {
+      chai.request(server)
+        .post('/' + savedProject._id + '/mcp/native/unknown-server/connect')
+        .auth(email, pwd)
+        .end((err, res) => {
+
+          if (err) { console.error("err: ", err); }
+          if (log) { console.log("connect res.body: ", res.body); }
+
+          res.should.have.status(404);
+          res.body.should.have.property('success', false);
+          done();
+        });
+    });
+  });
+
+  it('connect-native-mcp-server', (done) => {
+    createProjectUser(done, (savedProject, email, pwd, done) => {
+      const serverId = 'tiledesk-communicator';
+
+      chai.request(server)
+        .post('/' + savedProject._id + '/mcp/native/' + serverId + '/connect')
+        .auth(email, pwd)
+        .end((err, connectRes) => {
+          
+          if (err) { console.error("err: ", err); }
+          if (log) { console.log("connect res.body: ", connectRes.body); }
+
+          connectRes.should.have.status(200);
+          expect(connectRes.body).to.be.an('object');
+          expect(connectRes.body.success).to.equal(true);
+          expect(connectRes.body.message).to.equal('Native MCP server connected successfully');
+          expect(connectRes.body.nativeId).to.equal(serverId);
+          connectRes.body.tools.should.be.an('array');
+          connectRes.body.tools.length.should.be.greaterThan(0);
+          connectRes.body.tools[0].should.have.property('name');
+          connectRes.body.tools.map((tool) => tool.name).should.include('reply_to_user');
+
+          done();
+        });
+    });
+  });
+
+  it('save-native-mcp-server-to-integration', (done) => {
+    createProjectUser(done, (savedProject, email, pwd, done) => {
+
+      let serverId = 'tiledesk-communicator';
+      chai.request(server)
+        .post('/' + savedProject._id + '/mcp/native/' + serverId + '/tools')
+        .auth(email, pwd)
+        .end((err, toolsRes) => {
+          
+          if (err) { console.error("err: ", err); }
+          if (log) { console.log("tools res.body: ", toolsRes.body); }
+
+          toolsRes.should.have.status(200);
+          expect(toolsRes.body).to.be.an('array');
+          const totalTools = toolsRes.body.length;
+          const tools = toolsRes.body.slice(0, totalTools - 2);
+          
+          chai.request(server)
+            .post('/' + savedProject._id + '/mcp/servers')
+            .auth(email, pwd)
+            .send({
+              type: 'native',
+              nativeId: 'tiledesk-communicator',
+              tools,
+              selectedTools: [{ name: 'reply_to_user' }]
+            })
+            .end((err, res) => {
+              
+              if (err) { console.error("err: ", err); }
+              if (log) { console.log("save res.body: ", res.body); }
+
+              res.should.have.status(200);
+              res.body.should.have.property('success', true);
+              res.body.server.should.have.property('type', 'native');
+              res.body.server.should.have.property('nativeId', 'tiledesk-communicator');
+              res.body.server.should.have.property('name', 'Tiledesk Communicator');
+              res.body.server.should.not.have.property('url');
+              res.body.server.tools.should.have.length(totalTools - 2);
+              res.body.server.selectedTools.should.deep.equal([{ name: 'reply_to_user' }]);
+
+              chai.request(server)
+                .get('/' + savedProject._id + '/integration/name/mcp')
+                .auth(email, pwd)
+                .end((err, integrationRes) => {
+                  
+                  if (err) { console.error("err: ", err); }
+                  if (log) { console.log("integration res.body: ", integrationRes.body); }
+
+                  integrationRes.should.have.status(200);
+                  integrationRes.body.should.have.property('name', 'mcp');
+                  integrationRes.body.value.servers.should.be.an('array');
+                  integrationRes.body.value.servers.should.have.length(1);
+                  integrationRes.body.value.servers[0].should.have.property('nativeId', 'tiledesk-communicator');
+                  integrationRes.body.value.servers[0].should.not.have.property('url');
+
+                  done();
+                });
+            });
+        });
+    });
+  });
+
+});