@tiledesk/tiledesk-server 2.20.2 → 2.22.0

package/CHANGELOG.md

@@ -7,6 +7,7 @@
 
 # 2.21.0
 - Addressed and resolved a security vulnerability
+- Updated tybot-connector to 2.1.11
 
 # 2.20.1
 - Fixed a security vulnerability on AI-related routes

package/config/winston.js

@@ -1,10 +1,18 @@
 var appRoot = require('app-root-path');
 var winston = require('winston');
 var config = require('./database');
+var { redactInfo } = require('../utils/logRedactor');
 
 var level = process.env.LOG_LEVEL || 'info'
 // console.log("level",level);
 
+// Scrub credentials (provider API keys, Pinecone key, bearer tokens) from every
+// logged value BEFORE any transport writes it. AxiosError objects carry the full
+// request body (with keys) in config.data; this strips them at the transport
+// layer so no call site can leak a key into stdout/app.log/MongoDB. See
+// utils/logRedactor.js.
+var redactFormat = winston.format((info) => redactInfo(info))();
+
 var options = {
     file: {
       level:level ,
@@ -26,7 +34,7 @@ var options = {
       json: true,
       colorize: true,
       // timestamp: true,
-      format: winston.format.simple() 
+      format: winston.format.simple()
       // format: winston.format.combine(
       //   winston.format.splat(),
       //   winston.format.simple()
@@ -45,11 +53,14 @@ var options = {
 
 
 
-  let logger = winston.createLogger({    
+  let logger = winston.createLogger({
+    // Logger-level format runs before every transport format, so redaction here
+    // covers Console, File AND the MongoDB transports added below.
+    format: redactFormat,
     transports: [
      new (winston.transports.Console)(options.console),
      new (winston.transports.File)(options.file),
-     //new (winston.transports.MongoDB)( {db: logsDb, collection: "logs"}) 
+     //new (winston.transports.MongoDB)( {db: logsDb, collection: "logs"})
     ],
     exitOnError: false, // do not exit on handled exceptions
   });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiledesk/tiledesk-server",
   "description": "The Tiledesk server module",
-  "version": "2.20.2",
+  "version": "2.22.0",
   "scripts": {
     "start": "node ./bin/www",
     "pretest": "mongodb-runner start",
@@ -49,7 +49,7 @@
     "@tiledesk/tiledesk-rasa-connector": "^1.0.10",
     "@tiledesk/tiledesk-sms-connector": "^0.1.13",
     "@tiledesk/tiledesk-telegram-connector": "^0.1.14",
-    "@tiledesk/tiledesk-tybot-connector": "^2.1.10",
+    "@tiledesk/tiledesk-tybot-connector": "^2.1.11",
     "@tiledesk/tiledesk-voice-twilio-connector": "^0.3.2",
     "@tiledesk/tiledesk-vxml-connector": "^0.1.91",
     "@tiledesk/tiledesk-whatsapp-connector": "1.0.26",

package/routes/kb.js

@@ -22,6 +22,28 @@ const aiService = require('../services/aiService');
 const aiManager = require('../services/aiManager');
 const integrationService = require('../services/integrationService');
 const kbEvent = require('../event/kbEvent');
+// Never return a raw error to the client: an AxiosError from the LLM
+// microservice serializes config.data (the request body, which carries the
+// provider/gptkey + Pinecone key) straight into the response. sanitizeAxiosError
+// reduces it to a safe { message }.
+const { sanitizeAxiosError } = require('../utils/sanitizeAxiosError');
+
+// Strip the vector-store credential from a namespace (or array of namespaces)
+// before returning it to a client. engine.apikey is seeded from
+// VECTOR_STORE_APIKEY and must never reach the dashboard/browser. Storage is
+// left untouched (the key is still used server-side when building LLM calls);
+// only the outbound representation is scrubbed.
+function stripNamespaceSecrets(ns) {
+  if (Array.isArray(ns)) {
+    ns.forEach(stripNamespaceSecrets);
+    return ns;
+  }
+  if (ns && ns.engine && typeof ns.engine === 'object') {
+    delete ns.engine.apikey;
+    delete ns.engine.api_key;
+  }
+  return ns;
+}
 
 const AMQP_MANAGER_URL = process.env.AMQP_MANAGER_URL;
 const JOB_TOPIC_EXCHANGE = process.env.JOB_TOPIC_EXCHANGE_TRAIN || 'tiledesk-trainer';
@@ -149,7 +171,7 @@ router.post('/scrape/single', async (req, res) => {
 
     const urls = await aiManager.fetchSitemap(data.source).catch((err) => {
       winston.error("Error fetching sitemap: ", err);
-      return res.status(500).send({ success: false, error: err });
+      return res.status(500).send({ success: false, error: sanitizeAxiosError(err) });
     })
 
     if (urls.length === 0) {
@@ -220,7 +242,7 @@ router.post('/scrape/single', async (req, res) => {
   KB.findById(data.id, (err, kb) => {
     if (err) {
       winston.error("findById error: ", err);
-      return res.status(500).send({ success: false, error: err });
+      return res.status(500).send({ success: false, error: sanitizeAxiosError(err) });
     }
 
     else if (!kb) {
@@ -345,7 +367,7 @@ router.post('/scrape/status', async (req, res) => {
   }).catch((err) => {
     winston.error("scrapeStatus err: ", err);
     let status = err.response.status;
-    res.status(status).send({ statusText: err.response.statusText, error: err.response.data.detail });
+    res.status(status).send({ statusText: err.response.statusText, error: sanitizeAxiosError(err) });
   })
 })
 
@@ -630,9 +652,9 @@ router.post('/qa', async (req, res) => {
     }).catch((err) => {
       winston.error('qa err: ', err);
       winston.error('qa err.response: ', err.response);
-      const message = (err.response && err.response.data && typeof err.response.data.pipe !== 'function' && err.response.data.detail)
-        ? err.response.data.detail
-        : (err.response && err.response.statusText) || err.message || String(err);
+      // sanitizeAxiosError never exposes the request body / detail[].input (which
+      // carries the provider key); it yields only a safe message string.
+      const message = sanitizeAxiosError(err).message;
       if (!res.headersSent) {
         res.status(err.response && err.response.status ? err.response.status : 500);
       }
@@ -671,10 +693,10 @@ router.post('/qa', async (req, res) => {
     winston.error("qa err.response: ", err.response);
     if (err.response && err.response.status) {
       let status = err.response.status;
-      res.status(status).send({ success: false, statusText: err.response.statusText, error: err.response.data.detail });
+      res.status(status).send({ success: false, statusText: err.response.statusText, error: sanitizeAxiosError(err) });
     }
     else {
-      res.status(500).send({ success: false, error: err });
+      res.status(500).send({ success: false, error: sanitizeAxiosError(err) });
     }
 
   })
@@ -864,7 +886,7 @@ router.delete('/delete', async (req, res) => {
   }).catch((err) => {
     winston.error("delete err: ", err);
     let status = err.response.status;
-    res.status(status).send({ statusText: err.response.statusText, error: err.response.data.detail });
+    res.status(status).send({ statusText: err.response.statusText, error: sanitizeAxiosError(err) });
   })
 
 })
@@ -901,7 +923,7 @@ router.delete('/deleteall', async (req, res) => {
   }).catch((err) => {
     winston.error("delete namespace err: ", err);
     let status = err.response.status;
-    res.status(status).send({ statusText: err.response.statusText, error: err.response.data.detail });
+    res.status(status).send({ statusText: err.response.statusText, error: sanitizeAxiosError(err) });
   })
 })
 /**
@@ -927,7 +949,7 @@ router.get('/namespace/all', async (req, res) => {
 
     if (err) {
       winston.error("find namespaces error: ", err);
-      return res.status(500).send({ success: false, error: err });
+      return res.status(500).send({ success: false, error: sanitizeAxiosError(err) });
     }
     else if (namespaces.length == 0) {
 
@@ -945,7 +967,7 @@ router.get('/namespace/all', async (req, res) => {
       new_namespace.save((err, savedNamespace) => {
         if (err) {
           winston.error("create default namespace error: ", err);
-          return res.status(500).send({ success: false, error: err });
+          return res.status(500).send({ success: false, error: sanitizeAxiosError(err) });
         }
 
         let namespaceObj = savedNamespace.toObject();
@@ -955,7 +977,7 @@ router.get('/namespace/all', async (req, res) => {
         let namespaces = [];
         namespaces.push(namespaceObj);
 
-        return res.status(200).send(namespaces);
+        return res.status(200).send(stripNamespaceSecrets(namespaces));
 
       })
 
@@ -974,7 +996,7 @@ router.get('/namespace/all', async (req, res) => {
       }
 
       winston.debug("namespaceObjArray: ", namespaceObjArray);
-      return res.status(200).send(namespaceObjArray);
+      return res.status(200).send(stripNamespaceSecrets(namespaceObjArray));
     }
   })
 })
@@ -995,7 +1017,7 @@ router.get('/namespace/:id/chunks/:content_id', async (req, res) => {
 
   let content = await KB.find({ id_project: project_id, namespace: namespace_id, _id: content_id }).catch((err) => {
     winston.error("find content error: ", err);
-    return res.status(403).send({ success: false, error: err })
+    return res.status(403).send({ success: false, error: sanitizeAxiosError(err) })
   })
 
   if (!content) {
@@ -1017,7 +1039,7 @@ router.get('/namespace/:id/chunks/:content_id', async (req, res) => {
   }).catch((err) => {
     winston.error("error getting content chunks err.response: ", err.response)
     winston.error("error getting content chunks err.data: ", err.data)
-    return res.status(500).send({ success: false, error: err });
+    return res.status(500).send({ success: false, error: sanitizeAxiosError(err) });
   })
 
 })
@@ -1039,7 +1061,7 @@ router.get('/namespace/:id/chatbots', async (req, res) => {
 
   let intents = await faq.find({ id_project: project_id, 'actions.namespace': namespace_id }).catch((err) => {
     winston.error("Error find intents: ", err);
-    return res.status(500).send({ success: false, message: 'Unable to retrieve intents using the selected namespace', error: err });
+    return res.status(500).send({ success: false, message: 'Unable to retrieve intents using the selected namespace', error: sanitizeAxiosError(err) });
   })
 
   if (!intents || intents.length == 0) {
@@ -1176,7 +1198,7 @@ router.post('/namespace', async (req, res) => {
   new_namespace.save((err, savedNamespace) => {
     if (err) {
       winston.error("create namespace error: ", err);
-      return res.status(500).send({ success: false, error: err });
+      return res.status(500).send({ success: false, error: sanitizeAxiosError(err) });
     }
 
     kbEvent.emit('kb.namespace.create', { req, savedNamespace, body, namespace_id, project_id });
@@ -1184,7 +1206,7 @@ router.post('/namespace', async (req, res) => {
     let namespaceObj = savedNamespace.toObject();
     delete namespaceObj._id;
     delete namespaceObj.__v;
-    return res.status(200).send(namespaceObj);
+    return res.status(200).send(stripNamespaceSecrets(namespaceObj));
   })
 })
 
@@ -1216,7 +1238,7 @@ router.post('/namespace/import/:id', upload.single('uploadFile'), async (req, re
 
   let namespaces = await Namespace.find({ id_project: id_project }).catch((err) => {
     winston.error("find namespaces error: ", err)
-    res.status(500).send({ success: false, error: err })
+    res.status(500).send({ success: false, error: sanitizeAxiosError(err) })
   })
 
   if (!namespaces || namespaces.length == 0) {
@@ -1310,7 +1332,7 @@ router.post('/namespace/import/:id', upload.single('uploadFile'), async (req, re
 
   let deleteResponse = await KB.deleteMany({ id_project: id_project, namespace: namespace_id, type: { $in: ['url', 'text', 'faq'] } }).catch((err) => {
     winston.error("deleteMany error: ", err);
-    return res.status(500).send({ success: false, error: err });
+    return res.status(500).send({ success: false, error: sanitizeAxiosError(err) });
   })
 
   winston.verbose("Content deletetion response: ", deleteResponse);
@@ -1401,7 +1423,7 @@ router.put('/namespace/:id', async (req, res) => {
   Namespace.findOneAndUpdate({ id: namespace_id }, update, { new: true, upsert: true }, (err, updatedNamespace) => {
     if (err) {
       winston.error("update namespace error: ", err);
-      return res.status(500).send({ success: false, error: err });
+      return res.status(500).send({ success: false, error: sanitizeAxiosError(err) });
     }
 
     kbEvent.emit('kb.namespace.update', { updatedNamespace, namespace_id });
@@ -1409,7 +1431,7 @@ router.put('/namespace/:id', async (req, res) => {
     let namespaceObj = updatedNamespace.toObject();
     delete namespaceObj._id;
     delete namespaceObj.__v;
-    res.status(200).send(namespaceObj);
+    res.status(200).send(stripNamespaceSecrets(namespaceObj));
   })
 })
 
@@ -1420,7 +1442,7 @@ router.delete('/namespace/:id', async (req, res) => {
 
   let namespace = await Namespace.findOne({ id_project: project_id, id: namespace_id }).catch((err) => {
     winston.error("find namespace error: ", err);
-    res.status(500).send({ success: false, error: err });
+    res.status(500).send({ success: false, error: sanitizeAxiosError(err) });
   })
 
   if (!namespace) {
@@ -1441,7 +1463,7 @@ router.delete('/namespace/:id', async (req, res) => {
 
       let deleteResponse = await KB.deleteMany({ id_project: project_id, namespace: namespace_id }).catch((err) => {
         winston.error("deleteMany error: ", err);
-        return res.status(500).send({ success: false, error: err });
+        return res.status(500).send({ success: false, error: sanitizeAxiosError(err) });
       })
       winston.debug("delete all contents response: ", deleteResponse);
 
@@ -1462,9 +1484,9 @@ router.delete('/namespace/:id', async (req, res) => {
       winston.error("deleteNamespace err.response: ", err.response);
       if (err.response && err.response.status) {
         let status = err.response.status;
-        res.status(status).send({ success: false, statusText: err.response.statusText, error: err.response.data.detail });
+        res.status(status).send({ success: false, statusText: err.response.statusText, error: sanitizeAxiosError(err) });
       } else {
-        res.status(500).send({ success: false, message: "Unable to delete namespace", error: err })
+        res.status(500).send({ success: false, message: "Unable to delete namespace", error: sanitizeAxiosError(err) })
       }
     })
 
@@ -1472,7 +1494,7 @@ router.delete('/namespace/:id', async (req, res) => {
 
     let namespace = await Namespace.findOne({ id: namespace_id }).catch((err) => {
       winston.error("findOne namespace error: ", err);
-      return res.status(500).send({ success: false, error: err });
+      return res.status(500).send({ success: false, error: sanitizeAxiosError(err) });
     })
     if (namespace.default === true) {
       winston.error("Default namespace cannot be deleted");
@@ -1484,13 +1506,13 @@ router.delete('/namespace/:id', async (req, res) => {
 
       let deleteResponse = await KB.deleteMany({ id_project: project_id, namespace: namespace_id }).catch((err) => {
         winston.error("deleteMany error: ", err);
-        return res.status(500).send({ success: false, error: err });
+        return res.status(500).send({ success: false, error: sanitizeAxiosError(err) });
       })
       winston.debug("delete all contents response: ", deleteResponse);
 
       let deleteNamespaceResponse = await Namespace.findOneAndDelete({ id: namespace_id }).catch((err) => {
         winston.error("deleteOne namespace error: ", err);
-        return res.status(500).send({ success: false, error: err });
+        return res.status(500).send({ success: false, error: sanitizeAxiosError(err) });
       })
       winston.debug("delete namespace response: ", deleteNamespaceResponse);
 
@@ -1609,7 +1631,7 @@ router.get('/', async (req, res) => {
       .exec((err, kbs) => {
         if (err) {
           winston.error("Find all kbs error: ", err);
-          return res.status(500).send({ success: false, error: err });
+          return res.status(500).send({ success: false, error: sanitizeAxiosError(err) });
         }
 
         winston.debug("KBs found: ", kbs);
@@ -1735,7 +1757,7 @@ router.post('/', async (req, res) => {
   KB.findOneAndUpdate({ id_project, type, source }, new_kb, { upsert: true, new: true, rawResult: true }, async (err, raw_content) => {
     if (err) {
       winston.error("findOneAndUpdate with upsert error: ", err);
-      res.status(500).send({ success: false, error: err });
+      res.status(500).send({ success: false, error: sanitizeAxiosError(err) });
     }
     else {
 
@@ -1988,7 +2010,7 @@ router.post('/csv', upload.single('uploadFile'), async (req, res) => {
     })
     .on("error", (err) => {
       winston.error("CSV parsing error: ", err);
-      res.status(400).send({ success: false, error: err });
+      res.status(400).send({ success: false, error: sanitizeAxiosError(err) });
     })
 
 })
@@ -2009,7 +2031,7 @@ router.post('/sitemap', async (req, res) => {
     res.status(200).send(data);
   }).catch((err) => {
     winston.error("Error fetching sitemap: ", err)
-    res.status(500).send({ success: false, error: err });
+    res.status(500).send({ success: false, error: sanitizeAxiosError(err) });
   })
 
 })
@@ -2057,7 +2079,7 @@ router.post('/sitemap/import', async (req, res) => {
 
   const data = await sitemap.fetch().catch((err) => {
     winston.error("Error fetching sitemap: ", err);
-    return res.status(500).send({ success: false, error: err });
+    return res.status(500).send({ success: false, error: sanitizeAxiosError(err) });
   })
 
   if (data.errors && data.errors.length > 0) {
@@ -2094,7 +2116,7 @@ router.post('/sitemap/import', async (req, res) => {
     saved_content = await KB.findOneAndUpdate({ id_project, type: 'sitemap', source, namespace: namespace_id }, sitemap_content, { upsert: true, new: true }).lean().exec();
   } catch (err) {
     winston.error("Error saving content: ", err);
-    return res.status(500).send({ success: false, error: err });
+    return res.status(500).send({ success: false, error: sanitizeAxiosError(err) });
   }
 
   const options = {
@@ -2205,7 +2227,7 @@ router.put('/:kb_id', async (req, res) => {
 
   } catch (err) {
     winston.error("Error updating content: ", err);
-    return res.status(500).send({ success: false, error: err });
+    return res.status(500).send({ success: false, error: sanitizeAxiosError(err) });
   }
 
   if (situated_context && situated_context === true && scrape_type === 0) {
@@ -2254,7 +2276,7 @@ router.put('/:kb_id', async (req, res) => {
     updated_content = await KB.findOneAndUpdate({ id_project, namespace: namespace_id, source }, new_content, { upsert: true, new: true }).lean().exec();
   } catch (err) {
     winston.error("Error updating content: ", err);
-    return res.status(500).send({ success: false, error: err });
+    return res.status(500).send({ success: false, error: sanitizeAxiosError(err) });
   }
 
   const embedding = aiManager.normalizeEmbedding(namespace.embedding);
@@ -2297,7 +2319,7 @@ router.delete('/:kb_id', async (req, res) => {
 
   let kb = await KB.findOne({ id_project: project_id, _id: kb_id }).catch((err) => {
     winston.warn("Unable to find kb. Error: ", err);
-    return res.status(500).send({ success: false, error: err })
+    return res.status(500).send({ success: false, error: sanitizeAxiosError(err) })
   })
 
   if (!kb) {
@@ -2322,7 +2344,7 @@ router.delete('/:kb_id', async (req, res) => {
       //return res.status(200).send({ success: true, message: "Scheduled jobs for deleting sitemap" });
     } catch (err) {
       winston.error("Error deleting sitemap: ", err);
-      return res.status(500).send({ success: false, error: err });
+      return res.status(500).send({ success: false, error: sanitizeAxiosError(err) });
     }
   }
 
@@ -2368,7 +2390,7 @@ router.delete('/:kb_id', async (req, res) => {
 
         if (err) {
           winston.error("Delete kb error: ", err);
-          return res.status(500).send({ success: false, error: err });
+          return res.status(500).send({ success: false, error: sanitizeAxiosError(err) });
         }
         emitKbContentDelete(deletedKb);
         res.status(200).send(deletedKb);
@@ -2394,7 +2416,7 @@ router.delete('/:kb_id', async (req, res) => {
 
   }).catch((err) => {
     let status = err.response?.status || 500;
-    res.status(status).send({ success: false, statusText: err.response.statusText, error: err.response.data.detail });
+    res.status(status).send({ success: false, statusText: err.response.statusText, error: sanitizeAxiosError(err) });
   })
 
 })

package/routes/llm.js

@@ -130,9 +130,11 @@ router.post('/preview', async (req, res) => {
         res.status(200).send(response.data)
     }).catch((err) => {
         if (err.response?.data?.detail?.[0]) {
-            res.status(400).send({ success: false, error: err.response.data.detail[0]?.msg, detail: err.response.data.detail });
+            // Only the message — never `detail` itself: detail[].input echoes the
+            // request body, which carries the provider key.
+            res.status(400).send({ success: false, error: err.response.data.detail[0]?.msg });
         } else if (err.response?.data?.detail?.answer) {
-            res.status(400).send({ success: false, error: err.response.data.detail.answer, detail: err.response.data.detail });
+            res.status(400).send({ success: false, error: err.response.data.detail.answer });
         } else if (err.response?.data) {
             res.status(axiosErrorStatus(err)).send({ success: false, error: sanitizeAxiosError(err) });
         } else {

package/utils/logRedactor.js

@@ -0,0 +1,86 @@
+/**
+ * Log redaction helpers.
+ *
+ * Winston serializes whatever is handed to it. Because credentials (OpenAI /
+ * provider keys, the Pinecone key, bearer tokens) travel inside request bodies
+ * to the LLM microservice, an AxiosError carries the full body in
+ * `err.config.data` and the bearer in `err.config.headers.Authorization`, and a
+ * `winston.error("...", err)` or `winston.debug("data:", data)` leaks them to
+ * stdout / app.log / the MongoDB log transport.
+ *
+ * `redactFormat` is a winston format that walks every logged value (message,
+ * merged metadata and splat args) and scrubs sensitive keys and key-shaped
+ * strings BEFORE any transport writes them. This closes the logging leak at the
+ * transport layer instead of at ~40 individual call sites.
+ */
+
+// Object keys whose value is a secret and must never be logged.
+const SENSITIVE_KEY_RE = /^(api_?key|gptkey|llm_key|apikey|embedding_key|token|password|passwd|secret|client_secret|authorization|x-auth-token|kb_webhook_token)$/i;
+
+const REDACTED = '[REDACTED]';
+const MAX_DEPTH = 8;
+
+// Scrub secrets that appear inside a raw string (e.g. the JSON string held in
+// axios `config.data`, or a bearer header rendered into a message).
+function redactString(str) {
+  if (typeof str !== 'string' || str.length === 0) return str;
+  return str
+    // provider keys: OpenAI (sk-..., sk-proj-...), Anthropic (sk-ant-...), Pinecone (pcsk_...), Google (AIza...)
+    .replace(/sk-(?:proj-|ant-)?[A-Za-z0-9_-]{12,}/g, 'sk-[REDACTED]')
+    .replace(/pcsk_[A-Za-z0-9_-]{12,}/g, 'pcsk_[REDACTED]')
+    .replace(/AIza[A-Za-z0-9_-]{20,}/g, 'AIza[REDACTED]')
+    // JSON-encoded secret fields inside a serialized body: "api_key":"..."
+    .replace(/("(?:api_?key|gptkey|llm_key|apikey|embedding_key|token|password|secret|client_secret)"\s*:\s*)"[^"]*"/gi, '$1"[REDACTED]"')
+    // bearer tokens
+    .replace(/Bearer\s+[A-Za-z0-9._-]+/gi, 'Bearer [REDACTED]');
+}
+
+// Recursively redact a value (object, array, or scalar). Returns a redacted copy
+// for objects/arrays; scalars are returned scrubbed. Guards against cycles and
+// runaway depth.
+function redactValue(value, seen, depth) {
+  if (depth > MAX_DEPTH) return '[Truncated]';
+  if (value === null || value === undefined) return value;
+  if (typeof value === 'string') return redactString(value);
+  if (typeof value !== 'object') return value;
+  if (seen.has(value)) return '[Circular]';
+  seen.add(value);
+
+  if (Array.isArray(value)) {
+    return value.map((v) => redactValue(v, seen, depth + 1));
+  }
+
+  // Preserve Error identity/message while scrubbing any attached props (axios
+  // errors attach `config`, `response`, etc.).
+  const out = {};
+  for (const key of Object.keys(value)) {
+    if (SENSITIVE_KEY_RE.test(key)) {
+      out[key] = REDACTED;
+    } else {
+      out[key] = redactValue(value[key], seen, depth + 1);
+    }
+  }
+  return out;
+}
+
+// Redact the winston `info` object in place, including the Symbol(splat) args
+// that hold the extra arguments of calls like `winston.error("msg:", err)`.
+function redactInfo(info) {
+  const seen = new WeakSet();
+  for (const key of Object.keys(info)) {
+    if (key === 'level') continue;
+    if (SENSITIVE_KEY_RE.test(key)) {
+      info[key] = REDACTED;
+    } else {
+      info[key] = redactValue(info[key], seen, 0);
+    }
+  }
+  const splatSym = Symbol.for('splat');
+  const splat = info[splatSym];
+  if (Array.isArray(splat)) {
+    info[splatSym] = splat.map((arg) => redactValue(arg, new WeakSet(), 0));
+  }
+  return info;
+}
+
+module.exports = { redactString, redactValue, redactInfo, SENSITIVE_KEY_RE };

package/utils/maskIntegrationSecrets.js

@@ -1,4 +1,4 @@
-const SECRET_KEYS = new Set(['apikey', 'api_key']);
+const SECRET_KEYS = new Set(['apikey', 'api_key', 'token', 'secret', 'client_secret', 'password']);
 
 const UNMASKED_START = 3;
 const UNMASKED_END = 4;