@tiledesk/tiledesk-server 2.18.4 → 2.18.16

package/routes/unanswered.js

@@ -2,6 +2,7 @@ const express = require('express');
 const router = express.Router();
 const { Namespace, UnansweredQuestion } = require('../models/kb_setting');
 var winston = require('../config/winston');
+var fastCsv = require('fast-csv');
 
 // Add a new unanswered question
 router.post('/', async (req, res) => {
@@ -252,6 +253,76 @@ router.get('/count/:namespace', async (req, res) => {
     }
 });
 
+router.get('/:namespace/export', async (req, res) => {
+    try {
+        const { namespace } = req.params;
+        const id_project = req.projectid;
+        const mode = String(req.query.mode || 'csv').toLowerCase();
+
+        if (mode !== 'csv' && mode !== 'json') {
+            return res.status(400).json({
+                success: false,
+                error: 'Invalid format. Use mode=json or mode=csv'
+            });
+        }
+
+        const isValidNamespace = await validateNamespace(id_project, namespace);
+        if (!isValidNamespace) {
+            return res.status(403).json({
+                success: false,
+                error: "Not allowed. The namespace does not belong to the current project."
+            });
+        }
+
+        const questions = await UnansweredQuestion.find({ id_project, namespace })
+            .sort({ createdAt: -1 })
+            .lean();
+
+        const safeFilename = String(namespace).replace(/[^\w.-]+/g, '_') || 'export';
+
+        if (mode === 'json') {
+            const questionsJson = questions.map((q) => {
+                const { __v, updatedAt, ...doc } = q;
+                return doc;
+            });
+            const payload = {
+                namespace,
+                exportedAt: new Date().toISOString(),
+                count: questionsJson.length,
+                questions: questionsJson
+            };
+            res.setHeader('Content-Type', 'application/json; charset=utf-8');
+            res.setHeader('Content-Disposition', `attachment; filename="unanswered-${safeFilename}.json"`);
+            return res.send(JSON.stringify(payload, null, 2));
+        }
+
+        res.setHeader('Content-Type', 'text/csv; charset=utf-8');
+        res.setHeader('Content-Disposition', `attachment; filename="unanswered-${safeFilename}.csv"`);
+
+        const csvStream = fastCsv.format({ headers: true });
+        csvStream.pipe(res);
+
+        for (const q of questions) {
+            csvStream.write({
+                id: String(q._id),
+                namespace: q.namespace,
+                question: q.question,
+                request_id: q.request_id || '',
+                createdAt: q.createdAt ? new Date(q.createdAt).toISOString() : ''
+            });
+        }
+        csvStream.end();
+    } catch (error) {
+        winston.error('Error exporting unanswered questions:', error);
+        if (!res.headersSent) {
+            res.status(500).json({
+                success: false,
+                error: "Error exporting unanswered questions"
+            });
+        }
+    }
+});
+
 // Helper function to validate namespace
 async function validateNamespace(id_project, namespace_id) {
     try {

package/routes/urlPreview.js

@@ -0,0 +1,57 @@
+const express = require('express');
+const router = express.Router();
+const winston = require('../config/winston');
+const urlPreviewService = require('../services/urlPreviewService');
+
+const PRIVATE_IP = /^(127\.|10\.|192\.168\.|172\.(1[6-9]|2\d|3[01])\.|0\.0\.0\.0|::1)/;
+const MAX_URLS = 10;
+
+function isSafeUrl(rawUrl) {
+  try {
+    const { protocol, hostname } = new URL(rawUrl);
+    if (!['http:', 'https:'].includes(protocol)) return false;
+    if (PRIVATE_IP.test(hostname)) return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// POST /:projectid/url-preview — public endpoint (used by the widget without auth)
+// Body: { "urls": ["https://example.com", "https://another.com"] }
+router.post('/', async (req, res) => {
+  const urls = req.body.urls;
+
+  if (!Array.isArray(urls) || urls.length === 0) {
+    return res.status(422).send({ success: false, error: 'urls must be a non-empty array' });
+  }
+
+  if (urls.length > MAX_URLS) {
+    return res.status(422).send({ success: false, error: `urls must contain at most ${MAX_URLS} items` });
+  }
+
+  const safeUrls = [];
+  const blocked = [];
+  for (const url of urls) {
+    if (isSafeUrl(url)) {
+      safeUrls.push(url);
+    } else {
+      blocked.push({ url, success: false, error: 'URL not allowed' });
+    }
+  }
+
+  try {
+    const fetched = safeUrls.length > 0 ? await urlPreviewService.fetchPagesPreviews(safeUrls) : [];
+    // Merge results preserving original order
+    const resultMap = new Map(fetched.map(r => [r.url, r]));
+    const previews = urls.map(url =>
+      resultMap.get(url) || blocked.find(b => b.url === url)
+    );
+    res.status(200).send(previews);
+  } catch (err) {
+    winston.error('[urlPreview] error', err);
+    res.status(500).send({ success: false, error: err.message || 'Internal error' });
+  }
+});
+
+module.exports = router;

package/routes/webhook.js

@@ -6,6 +6,7 @@ const JobManager = require('../utils/jobs-worker-queue-manager/JobManagerV2');
 const { AiReindexService } = require('../services/aiReindexService');
 const { Webhook } = require('../models/webhook');
 const webhookService = require('../services/webhookService');
+const webhookEvent = require('../event/webhookEvent');
 const errorCodes = require('../errorCodes');
 const aiManager = require('../services/aiManager');
 var ObjectId = require('mongoose').Types.ObjectId;
@@ -311,6 +312,7 @@ router.all('/:webhook_id', async (req, res) => {
   //webhookService.run(webhook, payload)
   // To delete - End
   webhookService.run(webhook, payload, dev, redis_client).then((response) => {
+    webhookEvent.emit("webhook.triggered", { webhook: webhook, payload: payload });
     return res.status(200).send(response);
   }).catch((err) => {
     if (err.code === errorCodes.WEBHOOK.ERRORS.NO_PRELOADED_DEV_REQUEST) {

package/services/Scheduler.js

@@ -46,6 +46,19 @@ class Scheduler {
         }
     
     }
+
+    deleteSchedule(data, callback) {
+        winston.debug("(deleteScheduler) data: ", data);
+        this.jobManager.publishDelete(data, (err, ok) => {
+            let response_data = { success: true, message: "Scheduled" };
+            if (err) {
+                response_data = { success: false, message: "Task not scheduled" };
+            }
+            if (callback) {
+                callback(err, response_data);
+            }
+        });
+    }
     
 }
 

package/services/aiManager.js

@@ -412,6 +412,36 @@ class AiManager {
     })
   }
 
+  async deleteSitemap(sitemapContent, namespace) {
+
+    const sitemapContentId = sitemapContent._id;
+    const relatedContents = await KB.find({ id_project: sitemapContent.id_project, namespace: sitemapContent.namespace, sitemap_origin_id: sitemapContentId }).lean().exec();
+
+    if (!relatedContents.length) {
+      return;
+    }
+
+    const engine = namespace.engine || default_engine;
+    const scheduler = new Scheduler({ jobManager: jobManager });
+
+    await Promise.all(relatedContents.map((kb) => { 
+      return new Promise((resolve) => {
+        const data = {
+          id: kb._id,
+          namespace: kb.namespace,
+          engine: engine
+        };
+        scheduler.deleteSchedule(data, (err, result) => {
+          if (err) {
+            winston.error("deleteSitemap: deleteSchedule error for kb " + kb._id, err);
+          }
+          console.log("deleteSitemap: deleteSchedule result for kb " + kb._id, result);
+          resolve(result);
+        });
+      });
+    }));
+  }
+
   async saveBulk(operations, kbs, project_id, namespace) {
 
     return new Promise((resolve, reject) => {

package/services/urlPreviewService.js

@@ -0,0 +1,50 @@
+const axios = require('axios');
+const winston = require('../config/winston');
+
+class UrlPreviewService {
+
+  _extractMeta(html, url) {
+    const getMeta = (name) => {
+      const m = html.match(new RegExp(`<meta[^>]+(?:name|property)=["']${name}["'][^>]+content=["']([^"']+)["']`, 'i'))
+               || html.match(new RegExp(`<meta[^>]+content=["']([^"']+)["'][^>]+(?:name|property)=["']${name}["']`, 'i'));
+      return m ? m[1] : null;
+    };
+    const titleMatch = html.match(/<title[^>]*>([^<]+)<\/title>/i);
+    return {
+      url,
+      title:              getMeta('og:title') || (titleMatch && titleMatch[1].trim()) || null,
+      description:        getMeta('og:description') || getMeta('description') || null,
+      image:              getMeta('og:image') || getMeta('twitter:image') || null,
+      siteName:           getMeta('og:site_name') || null,
+      type:               getMeta('og:type') || null,
+      locale:             getMeta('og:locale') || null,
+      author:             getMeta('author') || getMeta('article:author') || null,
+      keywords:           getMeta('keywords') || null,
+      twitterCard:        getMeta('twitter:card') || null,
+      twitterTitle:       getMeta('twitter:title') || null,
+      twitterDescription: getMeta('twitter:description') || null,
+      twitterImage:       getMeta('twitter:image') || null,
+    };
+  }
+
+  async fetchPagePreview(url) {
+    const response = await axios.get(url, {
+      timeout: 10000,
+      headers: { 'User-Agent': 'Mozilla/5.0 (compatible; TiledeskBot/1.0)' },
+      maxContentLength: 2000000,
+    });
+    return this._extractMeta(response.data, url);
+  }
+
+  async fetchPagesPreviews(urls) {
+    const results = await Promise.allSettled(urls.map(url => this.fetchPagePreview(url)));
+    return results.map((result, i) => {
+      if (result.status === 'fulfilled') {
+        return { url: urls[i], success: true, data: result.value };
+      }
+      return { url: urls[i], success: false, error: result.reason?.message || 'Failed to fetch' };
+    });
+  }
+}
+
+module.exports = new UrlPreviewService();

package/utils/jobs-worker-queue-manager/JobManagerV2.js

@@ -21,15 +21,7 @@ class JobManager {
         var that = this;
         if (this.info) {console.log("[JobWorker] JobManager publisher started");}
         
-        this.queueManager.connect(function(status, err) {
-
-            if (err) {
-                console.log("[JobWorker] - connectAndStartPublisher - connection error: ", err);
-                if (callback) {
-                    callback(null, err)
-                    return;
-                }
-            }
+        this.queueManager.connect(function() {
             if (that.debug) {console.log("[JobWorker] Queue started");}
             that.queuePublisherConnected = true;
 
@@ -49,8 +41,7 @@ class JobManager {
                 } 
 
                 if (callback) {
-                    callback(status, null);
-                    return;
+                    callback();
                 }
             });
         });
@@ -108,10 +99,30 @@ class JobManager {
         //     this.connectAndStartPublisher();
         //     this.sendingJobs.push(packet);
 
-        // }
+        //         }
        
     }
 
+    publishDelete(payload, callback) {
+
+        var packet = { payload: payload };
+        const routingKey = this.queueManager.deleteRoutingKey;
+
+        if (this.queuePublisherConnected == true) {
+
+            if (this.debug) { console.log("[JobWorker] JobManager publishDelete routingKey: " + routingKey); }
+            this.queueManager.sendJson(packet, routingKey, (err, ok) => {
+                if (err) {
+                    console.error("sendJson (delete) error: ", err);
+                } else {
+                    if (this.debug) { console.log("sendJson (delete) ok"); }
+                }
+                callback(err, ok);
+            });
+
+        }
+    }
+
 
     //Deprecated
     schedule(fn, payload) {