@oas-tools/oas-telemetry 0.7.1 → 0.8.0-alpha.1

package/dist/cjs/tlm-plugin/pluginService.cjs

@@ -1,82 +1,81 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.pluginService = void 0;
-var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const logger_js_1 = __importDefault(require("../utils/logger.cjs"));
 class PluginService {
-  constructor() {
-    this.plugins = [];
-    this.enabled = false;
-  }
-  getPlugins() {
-    return this.plugins;
-  }
-  pushPlugin(plugin) {
-    this.plugins.push(plugin);
-  }
-  activatePlugin(pluginId) {
-    const plugin = this.plugins.find(p => p.id === pluginId);
-    if (plugin) {
-      plugin.active = true;
+    plugins = [];
+    enabled = false;
+    getPlugins() {
+        return this.plugins;
     }
-  }
-  deactivatePlugin(pluginId) {
-    const plugin = this.plugins.find(p => p.id === pluginId);
-    if (plugin) {
-      plugin.active = false;
+    pushPlugin(plugin) {
+        this.plugins.push(plugin);
     }
-  }
-  deletePlugin(pluginId) {
-    const plugin = this.plugins.find(p => p.id === pluginId);
-    if (plugin?.process && !plugin.process.killed) {
-      plugin.process.kill(1);
+    activatePlugin(pluginId) {
+        const plugin = this.plugins.find((p) => p.id === pluginId);
+        if (plugin) {
+            plugin.active = true;
+        }
+    }
+    deactivatePlugin(pluginId) {
+        const plugin = this.plugins.find((p) => p.id === pluginId);
+        if (plugin) {
+            plugin.active = false;
+        }
     }
-    this.plugins = this.plugins.filter(p => p.id !== pluginId);
-  }
-  broadcastToPlugins(type, payload) {
-    if (!this.enabled) return;
-    this.plugins.forEach((plugin, i) => {
-      if (!plugin.active) return;
-      if (plugin.process) {
-        if (plugin.process.connected) {
-          try {
-            plugin.process.send({
-              type,
-              payload
-            });
-            _logger.default.debug(`Sent ${type} to child-process plugin <${plugin.name}> (#${i})`);
-          } catch (err) {
-            _logger.default.error(`Failed to send ${type} to plugin <${plugin.name}> (#${i}):`, err);
-          }
-        } else {
-          _logger.default.warn(`Plugin <${plugin.name}> (#${i}) is not connected. Skipping ${type}.`);
+    deletePlugin(pluginId) {
+        const plugin = this.plugins.find((p) => p.id === pluginId);
+        if (plugin?.process && !plugin.process.killed) {
+            plugin.process.kill(1);
         }
-      } else {
-        _logger.default.debug(`Plugin <${plugin.name}> does not implement ${type}. Skipping.`);
-      }
-    });
-  }
-  /**
-   * Broadcast a new metric to all active plugins
-   */
-  broadcastMetric(metric) {
-    this.broadcastToPlugins("newMetric", metric);
-  }
-  /**
-   * Broadcast a new log to all active plugins
-   */
-  broadcastLog(log) {
-    this.broadcastToPlugins("newLog", log);
-  }
-  /**
-   * Broadcast a new trace to all active plugins
-   * TODO: rename to span (trace is the whole trace, span is a single unit of work within a trace)
-   */
-  broadcastTrace(trace) {
-    this.broadcastToPlugins("newTrace", trace);
-  }
+        this.plugins = this.plugins.filter((p) => p.id !== pluginId);
+    }
+    broadcastToPlugins(type, payload) {
+        if (!this.enabled)
+            return;
+        this.plugins.forEach((plugin, i) => {
+            if (!plugin.active)
+                return;
+            if (plugin.process) {
+                if (plugin.process.connected) {
+                    try {
+                        plugin.process.send({ type, payload });
+                        logger_js_1.default.debug(`Sent ${type} to child-process plugin <${plugin.name}> (#${i})`);
+                    }
+                    catch (err) {
+                        logger_js_1.default.error(`Failed to send ${type} to plugin <${plugin.name}> (#${i}):`, err);
+                    }
+                }
+                else {
+                    logger_js_1.default.warn(`Plugin <${plugin.name}> (#${i}) is not connected. Skipping ${type}.`);
+                }
+            }
+            else {
+                logger_js_1.default.debug(`Plugin <${plugin.name}> does not implement ${type}. Skipping.`);
+            }
+        });
+    }
+    /**
+     * Broadcast a new metric to all active plugins
+     */
+    broadcastMetric(metric) {
+        this.broadcastToPlugins("newMetric", metric);
+    }
+    /**
+     * Broadcast a new log to all active plugins
+     */
+    broadcastLog(log) {
+        this.broadcastToPlugins("newLog", log);
+    }
+    /**
+     * Broadcast a new trace to all active plugins
+     * TODO: rename to span (trace is the whole trace, span is a single unit of work within a trace)
+     */
+    broadcastTrace(trace) {
+        this.broadcastToPlugins("newTrace", trace);
+    }
 }
-const pluginService = exports.pluginService = new PluginService();
+exports.pluginService = new PluginService();

package/dist/cjs/tlm-trace/traceController.cjs

@@ -1,146 +1,163 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.stopTraces = exports.statusTraces = exports.startTraces = exports.setTraceRetentionTime = exports.resetTraces = exports.listTraces = exports.insertTracesToDb = exports.getTraceRetentionTime = exports.findTraces = void 0;
-var _telemetryRegistry = require("../telemetry/telemetryRegistry.cjs");
-var _regexUtils = require("../utils/regexUtils.cjs");
-const _excluded = ["_id"];
-function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
-function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
-const startTraces = (req, res) => {
-  _telemetryRegistry.inMemoryDbSpanExporter.enable();
-  res.send('Traces started');
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportTraces = exports.getTraceRetentionTime = exports.setTraceRetentionTime = exports.importTraces = exports.insertTracesToDb = exports.findTraces = exports.listTraces = exports.resetTraces = exports.statusTraces = exports.stopTraces = exports.startTraces = void 0;
+const telemetryRegistry_js_1 = require("../telemetry/telemetryRegistry.cjs");
+const regexUtils_js_1 = require("../utils/regexUtils.cjs");
+const traceService_js_1 = require("./traceService.cjs");
+const zlib_1 = require("zlib");
+const startTraces = (_req, res) => {
+    telemetryRegistry_js_1.inMemoryDbSpanExporter.enable();
+    res.send('Traces started');
 };
 exports.startTraces = startTraces;
-const stopTraces = (req, res) => {
-  _telemetryRegistry.inMemoryDbSpanExporter.disable();
-  res.send('Traces stopped');
+const stopTraces = (_req, res) => {
+    telemetryRegistry_js_1.inMemoryDbSpanExporter.disable();
+    res.send('Traces stopped');
 };
 exports.stopTraces = stopTraces;
-const statusTraces = (req, res) => {
-  const isRunning = _telemetryRegistry.inMemoryDbSpanExporter.isEnabled() || false;
-  res.send({
-    active: isRunning
-  });
+const statusTraces = (_req, res) => {
+    const isRunning = telemetryRegistry_js_1.inMemoryDbSpanExporter.isEnabled() || false;
+    res.send({ active: isRunning });
 };
 exports.statusTraces = statusTraces;
-const resetTraces = (req, res) => {
-  _telemetryRegistry.inMemoryDbSpanExporter.reset();
-  res.send('Traces reset');
+const resetTraces = (_req, res) => {
+    telemetryRegistry_js_1.inMemoryDbSpanExporter.reset();
+    res.send('Traces reset');
 };
 exports.resetTraces = resetTraces;
-const listTraces = async (req, res) => {
-  try {
-    const spans = _telemetryRegistry.inMemoryDbSpanExporter.getFinishedSpans();
-    res.send({
-      spansCount: spans.length,
-      spans: spans
-    });
-  } catch (err) {
-    console.error(err);
-    res.status(500).send({
-      error: 'Failed to list traces data'
-    });
-  }
+const listTraces = async (_req, res) => {
+    try {
+        const spans = telemetryRegistry_js_1.inMemoryDbSpanExporter.getFinishedSpans();
+        res.send({ spansCount: spans.length, spans: spans });
+    }
+    catch (err) {
+        console.error(err);
+        res.status(500).send({ error: 'Failed to list traces data' });
+    }
 };
 exports.listTraces = listTraces;
-const findTraces = (req, res) => {
-  const body = req.body;
-  const query = body?.query ? body.query : {};
-  let processedQuery;
-  try {
-    processedQuery = (0, _regexUtils.convertRegexRecursively)(query);
-  } catch (error) {
-    console.error(error.message);
-    res.status(400).send({
-      error: error.message
-    });
-    return; // Exit if invalid regex was encountered
-  }
-  _telemetryRegistry.inMemoryDbSpanExporter.find(processedQuery, (err, docs) => {
-    if (err) {
-      console.error(err);
-      res.status(400).send({
-        spansCount: 0,
-        spans: [],
-        error: err.message
-      });
-      return; // Exit the function to prevent further execution
+const findTraces = async (req, res) => {
+    const body = req.body || {};
+    const findQuery = body.query || {};
+    const limit = parseInt(body.limit) || 50;
+    const sortOrder = body.sort || null;
+    let processedQuery;
+    try {
+        processedQuery = (0, regexUtils_js_1.convertRegexRecursively)(findQuery);
+    }
+    catch (error) {
+        console.error(error.message);
+        res.status(400).send({ error: error.message });
+        return; // Exit if invalid regex was encountered
+    }
+    try {
+        const findConfig = {
+            query: processedQuery,
+            limit,
+            sortOrder
+        };
+        const docs = await telemetryRegistry_js_1.inMemoryDbSpanExporter.find(findConfig);
+        res.send({
+            spansCount: docs.length,
+            spans: docs,
+        });
+    }
+    catch (err) {
+        console.error(err);
+        res.status(500).send({ spansCount: 0, spans: [], error: err.message });
     }
-    const spans = docs;
-    res.send({
-      spansCount: spans.length,
-      spans: spans
-    });
-  });
 };
 exports.findTraces = findTraces;
 const insertTracesToDb = async (req, res) => {
-  const jsonContent = req.body.spans;
-  const resetData = req.query.reset === 'true';
-  if (!Array.isArray(jsonContent)) {
-    res.status(400).send({
-      error: 'Invalid data format.'
-    });
-    return;
-  }
-  const cleanedTraces = jsonContent.map(trace => {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const {
-        _id
-      } = trace,
-      rest = _objectWithoutProperties(trace, _excluded); // Remove _id if it exists
-    return rest; // Return the cleaned trace object
-  });
-  try {
-    let message = '';
-    if (resetData) {
-      _telemetryRegistry.inMemoryDbSpanExporter.reset();
-      message += 'Traces Database reset. ';
+    const jsonContent = (req.body || {}).spans;
+    const resetData = req.query.reset === 'true';
+    if (!Array.isArray(jsonContent)) {
+        res.status(400).send({ error: 'Invalid data format.' });
+        return;
     }
-    await new Promise((resolve, reject) => {
-      _telemetryRegistry.inMemoryDbSpanExporter.insert(cleanedTraces, (err, newDocs) => {
-        if (err) {
-          console.error('Error inserting traces:', err);
-          return reject(err);
+    const cleanedTraces = (0, traceService_js_1.sanitizeTraceRecords)(jsonContent);
+    try {
+        let message = '';
+        await (0, traceService_js_1.importTracesToMemory)(cleanedTraces, { reset: resetData });
+        if (resetData) {
+            message += 'Traces Database reset. ';
         }
-        resolve(newDocs);
-      });
-    });
-    message += `Inserted ${cleanedTraces.length} traces.`;
-    res.send({
-      message,
-      InsertedTracesCount: cleanedTraces.length
-    });
-  } catch (err) {
-    console.error(err);
-    res.status(500).send({
-      error: 'Failed to reset and insert data',
-      details: err.message
-    });
-  }
+        message += `Inserted ${cleanedTraces.length} traces.`;
+        res.send({ message, InsertedTracesCount: cleanedTraces.length });
+    }
+    catch (err) {
+        console.error(err);
+        res.status(500).send({ error: 'Failed to reset and insert data', details: err.message });
+    }
 };
 exports.insertTracesToDb = insertTracesToDb;
+const importTraces = async (req, res) => {
+    const resetData = req.query.reset === 'true';
+    const body = req.body || {};
+    const importedSpans = Array.isArray(body) ? body : body.spans;
+    try {
+        if (!Array.isArray(importedSpans)) {
+            res.status(400).send({ error: 'Invalid data format. Expected an array in request body or body.spans.' });
+            return;
+        }
+        const cleanedTraces = (0, traceService_js_1.sanitizeTraceRecords)(importedSpans);
+        let message = '';
+        await (0, traceService_js_1.importTracesToMemory)(cleanedTraces, { reset: resetData });
+        if (resetData) {
+            message += 'Traces Database reset. ';
+        }
+        message += `Imported ${cleanedTraces.length} traces.`;
+        res.send({ message, ImportedTracesCount: cleanedTraces.length });
+    }
+    catch (err) {
+        console.error('Import failed:', err);
+        res.status(400).send({ error: 'Failed to import traces', details: err.message });
+    }
+};
+exports.importTraces = importTraces;
 const setTraceRetentionTime = (req, res) => {
-  const retentionTimeInSeconds = req.body.retentionTimeInSeconds;
-  if (typeof retentionTimeInSeconds !== 'number' || retentionTimeInSeconds <= 0) {
-    res.status(400).send({
-      error: 'Invalid retention time. Must be a positive number.'
-    });
-    return;
-  }
-  _telemetryRegistry.inMemoryDbSpanExporter.retentionTimeInSeconds = retentionTimeInSeconds;
-  res.send({
-    message: `Retention time set to ${retentionTimeInSeconds} seconds.`
-  });
+    const retentionTimeInSeconds = (req.body || {}).retentionTimeInSeconds;
+    if (typeof retentionTimeInSeconds !== 'number' || retentionTimeInSeconds <= 0) {
+        res.status(400).send({ error: 'Invalid retention time. Must be a positive number.' });
+        return;
+    }
+    telemetryRegistry_js_1.inMemoryDbSpanExporter.retentionTimeInSeconds = retentionTimeInSeconds;
+    res.send({ message: `Retention time set to ${retentionTimeInSeconds} seconds.` });
 };
 exports.setTraceRetentionTime = setTraceRetentionTime;
-const getTraceRetentionTime = (req, res) => {
-  const retentionTimeInSeconds = _telemetryRegistry.inMemoryDbSpanExporter.retentionTimeInSeconds || 0;
-  res.send({
-    retentionTimeInSeconds: retentionTimeInSeconds
-  });
+const getTraceRetentionTime = (_req, res) => {
+    const retentionTimeInSeconds = telemetryRegistry_js_1.inMemoryDbSpanExporter.retentionTimeInSeconds || 0;
+    res.send({ retentionTimeInSeconds: retentionTimeInSeconds });
+};
+exports.getTraceRetentionTime = getTraceRetentionTime;
+const exportTraces = async (req, res) => {
+    try {
+        const findConfig = {
+            query: {},
+            sortOrder: { startTime: -1 }
+        };
+        const docs = await telemetryRegistry_js_1.inMemoryDbSpanExporter.find(findConfig);
+        const responseBody = { spansCount: docs.length, spans: docs };
+        const payload = JSON.stringify(responseBody);
+        const payloadSize = Buffer.byteLength(payload, 'utf-8');
+        const acceptsGzip = String(req.headers['accept-encoding'] || '').includes('gzip');
+        const timestamp = new Date().toISOString().slice(0, 19).replace(/[-T:]/g, '');
+        res.setHeader('Content-Type', 'application/json');
+        res.setHeader('Content-Disposition', `attachment; filename="traces-${timestamp}.json"`);
+        res.setHeader('Vary', 'Accept-Encoding');
+        if (acceptsGzip && payloadSize > 64 * 1024) {
+            const compressed = (0, zlib_1.gzipSync)(payload);
+            res.setHeader('Content-Encoding', 'gzip');
+            res.setHeader('Content-Length', compressed.length.toString());
+            res.end(compressed);
+            return;
+        }
+        res.setHeader('Content-Length', payloadSize.toString());
+        res.end(payload);
+    }
+    catch (err) {
+        console.error('Failed to export traces:', err);
+        res.status(500).send({ error: 'Failed to export traces', details: err.message });
+    }
 };
-exports.getTraceRetentionTime = getTraceRetentionTime;
+exports.exportTraces = exportTraces;

package/dist/cjs/tlm-trace/traceRoutes.cjs

@@ -1,24 +1,23 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getTraceRoutes = exports.default = void 0;
-var _express = require("express");
-var _traceController = require("./traceController.cjs");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTraceRoutes = void 0;
+const express_1 = require("express");
+const traceController_js_1 = require("./traceController.cjs");
 const getTraceRoutes = () => {
-  const router = (0, _express.Router)();
-  // Telemetry Control
-  router.post('/start', _traceController.startTraces);
-  router.post('/stop', _traceController.stopTraces);
-  router.get('/status', _traceController.statusTraces);
-  router.post('/reset', _traceController.resetTraces);
-  router.get('/', _traceController.listTraces);
-  router.post('/', _traceController.insertTracesToDb);
-  router.post('/find', _traceController.findTraces);
-  router.post('/retention-time', _traceController.setTraceRetentionTime);
-  router.get('/retention-time', _traceController.getTraceRetentionTime);
-  return router;
+    const router = (0, express_1.Router)();
+    // Telemetry Control
+    router.post('/start', traceController_js_1.startTraces);
+    router.post('/stop', traceController_js_1.stopTraces);
+    router.get('/status', traceController_js_1.statusTraces);
+    router.post('/reset', traceController_js_1.resetTraces);
+    router.get('/export', traceController_js_1.exportTraces);
+    router.post('/import', traceController_js_1.importTraces);
+    router.get('/', traceController_js_1.listTraces);
+    router.post('/', traceController_js_1.insertTracesToDb);
+    router.post('/find', traceController_js_1.findTraces);
+    router.post('/retention-time', traceController_js_1.setTraceRetentionTime);
+    router.get('/retention-time', traceController_js_1.getTraceRetentionTime);
+    return router;
 };
 exports.getTraceRoutes = getTraceRoutes;
-var _default = exports.default = getTraceRoutes;
+exports.default = exports.getTraceRoutes;

package/dist/cjs/tlm-trace/traceService.cjs

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeTraceRecords = sanitizeTraceRecords;
+exports.importTracesToMemory = importTracesToMemory;
+const telemetryRegistry_js_1 = require("../telemetry/telemetryRegistry.cjs");
+function sanitizeTraceRecords(records) {
+    return records.map((record) => {
+        const { _id, ...rest } = record;
+        return rest;
+    });
+}
+async function importTracesToMemory(records, options) {
+    if (options?.reset) {
+        telemetryRegistry_js_1.inMemoryDbSpanExporter.reset();
+    }
+    if (!records.length) {
+        return 0;
+    }
+    await new Promise((resolve, reject) => {
+        telemetryRegistry_js_1.inMemoryDbSpanExporter.insert(records, (err) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve();
+        });
+    });
+    return records.length;
+}

package/dist/cjs/tlm-ui/uiRoutes.cjs

@@ -1,37 +1,68 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
 });
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.getUIRoutes = void 0;
-var _express = _interopRequireWildcard(require("express"));
-var _path = _interopRequireDefault(require("path"));
-var _url = require("url");
-var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
-var _bootConfig = require("../config/bootConfig.cjs");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+const express_1 = __importStar(require("express"));
+const path_1 = __importDefault(require("path"));
+const url_1 = require("url");
+const logger_js_1 = __importDefault(require("../utils/logger.cjs"));
+const bootConfig_js_1 = require("../config/bootConfig.cjs");
 const getUIRoutes = () => {
-  // This is when this file is in /dist
-  let relativePath = '../../ui';
-  // This is when this file in in /src
-  if (_bootConfig.bootEnvVariables.OASTLM_BOOT_ENV === 'development') {
-    relativePath = '../../dist/ui';
-    _logger.default.warn('🚧 This process is serving the OASTLM UI from the build directory, but you are in development mode. For live updates, run the React app separately and access it at http://localhost:5173/.');
-  }
-  const customFilename = (0, _url.fileURLToPath)(require('url').pathToFileURL(__filename).toString());
-  const customDirname = _path.default.dirname(customFilename);
-  const staticFilesPath = _path.default.join(customDirname, relativePath);
-  const router = (0, _express.Router)();
-  // This only works once the app is built: src/ --> dist/esm/
-  // This file: dist/esm/routes/
-  // UI bundle: dist/ui/
-  // For development, the UI is served separately.
-  router.use(_express.default.static(staticFilesPath));
-  router.get('*', (_req, res) => {
-    // Serve the index.html file for all routes
-    res.sendFile(_path.default.join(staticFilesPath, 'index.html'));
-  });
-  return router;
+    // This is when this file is in /dist
+    let relativePath = '../../ui';
+    // This is when this file in in /src
+    if (bootConfig_js_1.bootEnvVariables.OASTLM_BOOT_ENV === 'development') {
+        relativePath = '../../dist/ui';
+        logger_js_1.default.warn('🚧 This process is serving the OASTLM UI from the build directory, but you are in development mode. For live updates, run the React app separately and access it at http://localhost:5173/.');
+    }
+    const isCjs = typeof __filename !== "undefined" && typeof __dirname !== "undefined";
+    // @ts-ignore -- import.meta no existe en el build CJS
+    const currentDirectory = isCjs ? __dirname : path_1.default.dirname((0, url_1.fileURLToPath)(__filename));
+    const staticFilesPath = path_1.default.join(currentDirectory, relativePath);
+    const router = (0, express_1.Router)();
+    // This only works once the app is built: src/ --> dist/esm/
+    // This file: dist/esm/routes/
+    // UI bundle: dist/ui/
+    // For development, the UI is served separately.
+    router.use(express_1.default.static(staticFilesPath));
+    router.use((_req, res) => {
+        res.sendFile(path_1.default.join(staticFilesPath, 'index.html'));
+    });
+    return router;
 };
-exports.getUIRoutes = getUIRoutes;
+exports.getUIRoutes = getUIRoutes;