@red-hat-developer-hub/backstage-plugin-intelligent-assistant-backend 3.0.0

package/dist/service/router.cjs.js

@@ -0,0 +1,638 @@
+'use strict';
+
+var rootHttpRouter = require('@backstage/backend-defaults/rootHttpRouter');
+var errors = require('@backstage/errors');
+var pluginPermissionNode = require('@backstage/plugin-permission-node');
+var express = require('express');
+var httpProxyMiddleware = require('http-proxy-middleware');
+var backstagePluginIntelligentAssistantCommon = require('@red-hat-developer-hub/backstage-plugin-intelligent-assistant-common');
+var node_stream = require('node:stream');
+var constant = require('./constant.cjs.js');
+var mcpServerStore = require('./mcp-server-store.cjs.js');
+var mcpServerValidator = require('./mcp-server-validator.cjs.js');
+var createPermissionMiddleware = require('./middleware/createPermissionMiddleware.cjs.js');
+var createRateLimitMiddleware = require('./middleware/createRateLimitMiddleware.cjs.js');
+var getIdentity = require('./middleware/getIdentity.cjs.js');
+var VectorStoresOperator = require('./notebooks/VectorStoresOperator.cjs.js');
+var permission = require('./permission.cjs.js');
+var tokenEncryption = require('./token-encryption.cjs.js');
+var utils = require('./utils.cjs.js');
+var validation = require('./validation.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var express__default = /*#__PURE__*/_interopDefaultCompat(express);
+
+async function buildMcpHeaders(servers, store, userEntityRef, options) {
+  const headers = {};
+  const userSettings = await store.listByUser(userEntityRef);
+  const settingsMap = new Map(userSettings.map((s) => [s.server_name, s]));
+  for (const server of servers) {
+    const setting = settingsMap.get(server.name);
+    const enabled = setting ? Boolean(setting.enabled) : true;
+    if (!enabled) continue;
+    if (server.auth === "dcr") {
+      if (options?.dcrAuth) {
+        try {
+          const { token } = await options.dcrAuth.authService.getPluginRequestToken({
+            onBehalfOf: options.dcrAuth.credentials,
+            targetPluginId: "mcp-actions"
+          });
+          headers[server.name] = { Authorization: `${token}` };
+        } catch (err) {
+          options?.logger?.error(
+            `Failed to mint DCR token for MCP server '${server.name}': ${err}`
+          );
+        }
+      } else {
+        options?.logger?.warn(
+          `MCP server '${server.name}' has auth: dcr but AuthService is not available; skipping`
+        );
+      }
+    } else {
+      const token = setting?.token || server.token;
+      if (token) {
+        headers[server.name] = { Authorization: `${token}` };
+      }
+    }
+  }
+  return Object.keys(headers).length > 0 ? JSON.stringify(headers) : "";
+}
+async function createRouter(options) {
+  const { logger, config, database, httpAuth, auth, userInfo, permissions } = options;
+  const router = express.Router();
+  router.use(express__default.default.json());
+  const port = config.getOptionalNumber("intelligent-assistant.servicePort") ?? constant.DEFAULT_LIGHTSPEED_SERVICE_PORT;
+  const system_prompt = config.getOptionalString(
+    "intelligent-assistant.systemPrompt"
+  );
+  const lcsBaseUrl = `http://${constant.DEFAULT_LIGHTSPEED_SERVICE_HOST}:${port}`;
+  const apiProxy = httpProxyMiddleware.createProxyMiddleware({
+    target: lcsBaseUrl,
+    changeOrigin: true,
+    pathRewrite: (path, req) => {
+      const userEntityRef = req.userEntityRef;
+      const newPath = utils.rewriteProxyPath(path, userEntityRef);
+      if (newPath !== path) {
+        logger.info(`Rewriting path from ${path} to ${newPath}`);
+      }
+      return newPath;
+    }
+  });
+  const vectorStoresOperator = VectorStoresOperator.VectorStoresOperator.getInstance(
+    lcsBaseUrl,
+    logger
+  );
+  const mcpServersConfig = config.getOptionalConfigArray(
+    "intelligent-assistant.mcpServers"
+  );
+  const staticServers = [];
+  if (mcpServersConfig) {
+    for (const mcpServer of mcpServersConfig) {
+      const authValue = mcpServer.getOptionalString("auth")?.toLowerCase();
+      if (authValue && authValue !== "dcr") {
+        logger.warn(
+          `MCP server '${mcpServer.getString("name")}' has unsupported auth value '${authValue}'; only 'dcr' is supported \u2014 falling back to static-token mode`
+        );
+      }
+      staticServers.push({
+        name: mcpServer.getString("name"),
+        token: mcpServer.getOptionalString("token"),
+        auth: authValue === "dcr" ? "dcr" : void 0
+      });
+    }
+  }
+  const dbClient = await database.getClient();
+  const encryptor = tokenEncryption.createTokenEncryptor(config, logger);
+  const settingsStore = new mcpServerStore.McpUserSettingsStore(dbClient, encryptor, logger);
+  const mcpValidator = new mcpServerValidator.McpServerValidator(logger);
+  const lcsUrlCache = /* @__PURE__ */ new Map();
+  async function refreshLcsUrlCache() {
+    try {
+      const response = await fetch(`${lcsBaseUrl}/v1/mcp-servers`, {
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (!response.ok) {
+        logger.warn(
+          `Failed to fetch MCP server URLs from LCS: HTTP ${response.status}`
+        );
+        return;
+      }
+      const data = await response.json();
+      for (const s of data.servers) {
+        lcsUrlCache.set(s.name, s.url);
+      }
+      logger.info(`Cached ${lcsUrlCache.size} MCP server URL(s) from LCS`);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.warn(`Failed to fetch MCP server URLs from LCS: ${msg}`);
+    }
+  }
+  function resolveServerUrl(serverName) {
+    return lcsUrlCache.get(serverName);
+  }
+  refreshLcsUrlCache().catch(() => {
+  });
+  router.get("/health", (_, response) => {
+    response.json({ status: "ok" });
+  });
+  const permissionIntegrationRouter = pluginPermissionNode.createPermissionIntegrationRouter({
+    permissions: backstagePluginIntelligentAssistantCommon.lightspeedPermissions
+  });
+  router.use(permissionIntegrationRouter);
+  const identityMiddleware = getIdentity.createIdentityMiddleware(
+    httpAuth,
+    userInfo,
+    logger
+  );
+  router.use((req, res, next) => {
+    if (req.path.startsWith("/notebooks")) {
+      return next();
+    }
+    return identityMiddleware(req, res, next);
+  });
+  const authorizer = permission.userPermissionAuthorization(permissions);
+  function requirePermission(permission) {
+    return createPermissionMiddleware.createPermissionMiddleware(authorizer, permission, logger);
+  }
+  const expensiveRateLimiter = createRateLimitMiddleware.createRateLimitMiddleware(
+    config,
+    "expensive",
+    logger
+  );
+  const generalRateLimiter = createRateLimitMiddleware.createRateLimitMiddleware(
+    config,
+    "general",
+    logger
+  );
+  router.get(
+    "/mcp-servers",
+    generalRateLimiter,
+    requirePermission(backstagePluginIntelligentAssistantCommon.lightspeedMcpReadPermission),
+    async (req, res) => {
+      try {
+        const { userEntityRef } = getIdentity.getIdentity(req);
+        const userSettings = await settingsStore.listByUser(userEntityRef);
+        const settingsMap = new Map(userSettings.map((s) => [s.server_name, s]));
+        const hasAllUrls = staticServers.every((s) => lcsUrlCache.has(s.name));
+        if (!hasAllUrls) {
+          await refreshLcsUrlCache();
+        }
+        const servers = staticServers.map((server) => {
+          const setting = settingsMap.get(server.name);
+          return {
+            name: server.name,
+            url: resolveServerUrl(server.name),
+            enabled: setting ? Boolean(setting.enabled) : true,
+            status: setting?.status ?? "unknown",
+            toolCount: setting?.tool_count ?? 0,
+            // DCR servers always have a token (minted per-request); static servers check DB + config.
+            hasToken: server.auth === "dcr" || !!(setting?.token || server.token),
+            hasUserToken: !!setting?.token,
+            auth: server.auth
+          };
+        });
+        res.json({ servers });
+      } catch (error) {
+        logger.error(`Error listing MCP servers: ${error}`);
+        res.status(500).json({ error: "Failed to list MCP servers" });
+      }
+    }
+  );
+  router.post(
+    "/mcp-servers/validate",
+    generalRateLimiter,
+    requirePermission(backstagePluginIntelligentAssistantCommon.lightspeedMcpReadPermission),
+    async (req, res) => {
+      try {
+        const { url, token } = req.body;
+        if (!url || !token) {
+          res.status(400).json({ error: "url and token are required" });
+          return;
+        }
+        let knownUrls = new Set(lcsUrlCache.values());
+        if (!knownUrls.has(url)) {
+          await refreshLcsUrlCache();
+          knownUrls = new Set(lcsUrlCache.values());
+        }
+        if (!knownUrls.has(url)) {
+          res.status(400).json({
+            error: "URL not recognized \u2014 only MCP server URLs registered in LCS are allowed"
+          });
+          return;
+        }
+        const result = await mcpValidator.validate(url, token);
+        res.json(result);
+      } catch (error) {
+        logger.error(`Error validating MCP credentials: ${error}`);
+        res.status(500).json({ error: "Validation failed" });
+      }
+    }
+  );
+  router.post(
+    "/mcp-servers/:name/validate",
+    generalRateLimiter,
+    requirePermission(backstagePluginIntelligentAssistantCommon.lightspeedMcpManagePermission),
+    async (req, res) => {
+      try {
+        const { userEntityRef, credentials } = getIdentity.getIdentity(req);
+        const { name } = req.params;
+        const server = staticServers.find((s) => s.name === name);
+        if (!server) {
+          res.status(404).json({
+            error: `MCP server '${name}' is not configured \u2014 it must be defined in the Lightspeed Stack config and listed under intelligent-assistant.mcpServers in app-config`
+          });
+          return;
+        }
+        let serverUrl = resolveServerUrl(server.name);
+        if (!serverUrl) {
+          await refreshLcsUrlCache();
+          serverUrl = resolveServerUrl(server.name);
+        }
+        if (!serverUrl) {
+          res.status(400).json({ error: "Server has no URL \u2014 not found in LCS or config" });
+          return;
+        }
+        let effectiveToken;
+        if (server.auth === "dcr") {
+          try {
+            const { token: dcrToken } = await auth.getPluginRequestToken({
+              onBehalfOf: credentials,
+              targetPluginId: "mcp-actions"
+            });
+            effectiveToken = dcrToken;
+          } catch (err) {
+            logger.error(
+              `Failed to mint DCR token for server '${name}': ${err}`
+            );
+            res.status(502).json({
+              error: `Failed to mint authentication token for DCR server '${name}' \u2014 check Backstage auth configuration`
+            });
+            return;
+          }
+        } else {
+          const setting = await settingsStore.get(name, userEntityRef);
+          effectiveToken = setting?.token || server.token;
+        }
+        if (!effectiveToken) {
+          res.status(400).json({ error: "No token available \u2014 provide one first" });
+          return;
+        }
+        const validation = await mcpValidator.validate(
+          serverUrl,
+          effectiveToken
+        );
+        const status = validation.valid ? "connected" : "error";
+        await settingsStore.updateStatus(
+          name,
+          userEntityRef,
+          status,
+          validation.toolCount
+        );
+        res.json({
+          name,
+          status,
+          toolCount: validation.toolCount,
+          validation
+        });
+      } catch (error) {
+        logger.error(`Error validating MCP server: ${error}`);
+        res.status(500).json({ error: "Validation failed" });
+      }
+    }
+  );
+  router.patch(
+    "/mcp-servers/:name",
+    generalRateLimiter,
+    requirePermission(backstagePluginIntelligentAssistantCommon.lightspeedMcpManagePermission),
+    async (req, res) => {
+      try {
+        const { userEntityRef } = getIdentity.getIdentity(req);
+        const { name } = req.params;
+        const server = staticServers.find((s) => s.name === name);
+        if (!server) {
+          res.status(404).json({
+            error: `MCP server '${name}' is not configured \u2014 it must be defined in the Lightspeed Stack config and listed under intelligent-assistant.mcpServers in app-config`
+          });
+          return;
+        }
+        const body = req.body ?? {};
+        const hasEnabledField = Object.prototype.hasOwnProperty.call(
+          body,
+          "enabled"
+        );
+        const hasTokenField = Object.prototype.hasOwnProperty.call(
+          body,
+          "token"
+        );
+        const { enabled, token } = body;
+        if (!hasEnabledField && !hasTokenField) {
+          res.status(400).json({
+            error: "At least one of enabled or token must be provided"
+          });
+          return;
+        }
+        const setting = await settingsStore.upsert(name, userEntityRef, {
+          enabled: hasEnabledField ? enabled : void 0,
+          token: hasTokenField ? token : void 0
+        });
+        let validation;
+        let serverUrl = resolveServerUrl(server.name);
+        if (token && !serverUrl) {
+          await refreshLcsUrlCache();
+          serverUrl = resolveServerUrl(server.name);
+        }
+        if (token && serverUrl) {
+          validation = await mcpValidator.validate(serverUrl, token);
+          const newStatus = validation.valid ? "connected" : "error";
+          await settingsStore.updateStatus(
+            name,
+            userEntityRef,
+            newStatus,
+            validation.toolCount
+          );
+          setting.status = newStatus;
+          setting.tool_count = validation.toolCount;
+        }
+        const result = {
+          server: {
+            name: server.name,
+            url: resolveServerUrl(server.name),
+            enabled: Boolean(setting.enabled),
+            status: setting.status,
+            toolCount: setting.tool_count,
+            hasToken: server.auth === "dcr" || !!(setting.token || server.token),
+            hasUserToken: !!setting.token,
+            auth: server.auth
+          }
+        };
+        if (validation) result.validation = validation;
+        res.json(result);
+      } catch (error) {
+        logger.error(`Error updating MCP server settings: ${error}`);
+        res.status(500).json({ error: "Failed to update MCP server settings" });
+      }
+    }
+  );
+  router.get(
+    "/notebook-conversation-ids",
+    generalRateLimiter,
+    async (req, res) => {
+      try {
+        const { userEntityRef } = getIdentity.getIdentity(req);
+        const vectorStoresPage = await vectorStoresOperator.vectorStores.list();
+        const vectorStores = vectorStoresPage.data || [];
+        const conversationIds = [];
+        for (const store of vectorStores) {
+          const sessionUserId = store.metadata?.user_id;
+          const conversationId = store.metadata?.conversation_id;
+          if (sessionUserId === userEntityRef && conversationId) {
+            conversationIds.push(conversationId);
+          }
+        }
+        res.json({
+          conversation_ids: conversationIds
+        });
+      } catch (error) {
+        const errormsg = `Error fetching notebook conversation IDs: ${error}`;
+        logger.error(errormsg);
+        if (error instanceof errors.NotAllowedError) {
+          res.status(403).json({ error: error.message });
+        } else {
+          res.status(500).json({ error: errormsg });
+        }
+      }
+    }
+  );
+  router.get(
+    "/v1/models",
+    generalRateLimiter,
+    requirePermission(backstagePluginIntelligentAssistantCommon.lightspeedChatReadPermission),
+    apiProxy
+  );
+  router.get(
+    "/v1/shields",
+    generalRateLimiter,
+    requirePermission(backstagePluginIntelligentAssistantCommon.lightspeedChatReadPermission),
+    apiProxy
+  );
+  router.get(
+    "/v2/conversations",
+    generalRateLimiter,
+    requirePermission(backstagePluginIntelligentAssistantCommon.lightspeedChatReadPermission),
+    apiProxy
+  );
+  router.get(
+    "/v2/conversations/:conversation_id",
+    generalRateLimiter,
+    requirePermission(backstagePluginIntelligentAssistantCommon.lightspeedChatReadPermission),
+    apiProxy
+  );
+  router.delete(
+    "/v2/conversations/:conversation_id",
+    generalRateLimiter,
+    requirePermission(backstagePluginIntelligentAssistantCommon.lightspeedChatDeletePermission),
+    apiProxy
+  );
+  router.get(
+    "/v1/feedback/status",
+    generalRateLimiter,
+    requirePermission(backstagePluginIntelligentAssistantCommon.lightspeedChatReadPermission),
+    apiProxy
+  );
+  router.post(
+    "/v1/feedback",
+    generalRateLimiter,
+    requirePermission(backstagePluginIntelligentAssistantCommon.lightspeedChatCreatePermission),
+    async (request, response) => {
+      try {
+        const { userEntityRef } = getIdentity.getIdentity(request);
+        logger.info(`/v1/feedback receives call from user: ${userEntityRef}`);
+        const userQueryParam = `user_id=${encodeURIComponent(userEntityRef)}`;
+        const requestBody = JSON.stringify(request.body);
+        const fetchResponse = await fetch(
+          `${lcsBaseUrl}/v1/feedback?${userQueryParam}`,
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: requestBody
+          }
+        );
+        if (!fetchResponse.ok) {
+          await utils.handleLCSFetchError(
+            fetchResponse,
+            logger,
+            "sending feedback",
+            response
+          );
+          return;
+        }
+        const data = await fetchResponse.json();
+        response.status(fetchResponse.status).json(data);
+      } catch (error) {
+        const errormsg = `Error while sending feedback: ${error}`;
+        logger.error(errormsg);
+        response.status(500).json({ error: errormsg });
+      }
+    }
+  );
+  router.post(
+    "/v1/query/interrupt",
+    generalRateLimiter,
+    requirePermission(backstagePluginIntelligentAssistantCommon.lightspeedChatCreatePermission),
+    async (request, response) => {
+      try {
+        const { userEntityRef } = getIdentity.getIdentity(request);
+        const userQueryParam = `user_id=${encodeURIComponent(userEntityRef)}`;
+        const requestBody = JSON.stringify(request.body);
+        const fetchResponse = await fetch(
+          `${lcsBaseUrl}/v1/streaming_query/interrupt?${userQueryParam}`,
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: requestBody
+          }
+        );
+        if (!fetchResponse.ok) {
+          await utils.handleLCSFetchError(
+            fetchResponse,
+            logger,
+            "interrupting query",
+            response
+          );
+          return;
+        }
+        response.status(fetchResponse.status).json(await fetchResponse.json());
+      } catch (error) {
+        const errormsg = `Error while interrupting query: ${error}`;
+        logger.error(errormsg);
+        response.status(500).json({ error: errormsg });
+      }
+    }
+  );
+  router.post(
+    "/v1/query",
+    express__default.default.json({ limit: constant.EXPRESS_JSON_BODY_LIMIT }),
+    expensiveRateLimiter,
+    validation.validateCompletionsRequest,
+    requirePermission(backstagePluginIntelligentAssistantCommon.lightspeedChatCreatePermission),
+    async (request, response) => {
+      const { provider } = request.body;
+      try {
+        const { userEntityRef, credentials } = getIdentity.getIdentity(request);
+        logger.info(`/v1/query receives call from user: ${userEntityRef}`);
+        const userQueryParam = `user_id=${encodeURIComponent(userEntityRef)}`;
+        request.body.media_type = "application/json";
+        if (system_prompt && system_prompt.trim().length > 0) {
+          request.body.system_prompt = system_prompt;
+        }
+        const requestBody = JSON.stringify(request.body);
+        const mcpHeadersValue = await buildMcpHeaders(
+          staticServers,
+          settingsStore,
+          userEntityRef,
+          { dcrAuth: { authService: auth, credentials }, logger }
+        );
+        const abortController = new AbortController();
+        const fetchResponse = await fetch(
+          `${lcsBaseUrl}/v1/streaming_query?${userQueryParam}`,
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "MCP-HEADERS": mcpHeadersValue
+            },
+            body: requestBody,
+            signal: abortController.signal
+          }
+        );
+        if (!fetchResponse.ok) {
+          await utils.handleLCSFetchError(
+            fetchResponse,
+            logger,
+            "processing query",
+            response
+          );
+          return;
+        }
+        if (fetchResponse.body) {
+          const nodeStream = node_stream.Readable.fromWeb(fetchResponse.body);
+          nodeStream.on("error", (error) => {
+            logger.error(
+              `Upstream stream error while processing query: ${error}`
+            );
+            if (response.headersSent) {
+              response.destroy();
+            } else {
+              response.status(500).json({ error: "Stream error occurred" });
+            }
+            abortController.abort();
+          });
+          response.on("close", () => {
+            if (!response.writableFinished) {
+              logger.warn("Client disconnected while processing query");
+              nodeStream.destroy();
+              abortController.abort();
+            }
+          });
+          nodeStream.pipe(response);
+        }
+      } catch (error) {
+        const errormsg = `Error fetching completions from ${provider}: ${error}`;
+        logger.error(errormsg);
+        response.status(500).json({ error: errormsg });
+      }
+    }
+  );
+  router.put(
+    "/v2/conversations/:conversation_id",
+    generalRateLimiter,
+    requirePermission(backstagePluginIntelligentAssistantCommon.lightspeedChatCreatePermission),
+    async (request, response) => {
+      try {
+        const { userEntityRef } = getIdentity.getIdentity(request);
+        const conversation_id = request.params.conversation_id;
+        const requestBody = JSON.stringify(request.body);
+        const userQueryParam = `user_id=${encodeURIComponent(userEntityRef)}`;
+        const fetchResponse = await fetch(
+          `${lcsBaseUrl}/v2/conversations/${conversation_id}?${userQueryParam}`,
+          {
+            method: "PUT",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: requestBody
+          }
+        );
+        if (!fetchResponse.ok) {
+          await utils.handleLCSFetchError(
+            fetchResponse,
+            logger,
+            "updating conversation",
+            response
+          );
+          return;
+        }
+        const data = await fetchResponse.json();
+        response.status(fetchResponse.status).json(data);
+      } catch (error) {
+        const errormsg = `Error while updating topic summary: ${error}`;
+        logger.error(errormsg);
+        response.status(500).json({ error: errormsg });
+      }
+    }
+  );
+  router.use((_request, response) => {
+    response.status(404).json({ error: "Requested path is not available" });
+  });
+  const middleware = rootHttpRouter.MiddlewareFactory.create({ logger, config });
+  router.use(middleware.error());
+  return router;
+}
+
+exports.createRouter = createRouter;
+//# sourceMappingURL=router.cjs.js.map