@jfvilas/plugin-kwirth-backend 0.13.5 → 0.14.2

package/dist/index.cjs.js

@@ -2,587 +2,11 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var express = require('express');
-var Router = require('express-promise-router');
-var catalogClient = require('@backstage/catalog-client');
-var pluginKwirthCommon = require('@jfvilas/plugin-kwirth-common');
-var kwirthCommon = require('@jfvilas/kwirth-common');
-var backendPluginApi = require('@backstage/backend-plugin-api');
+var router = require('./service/router.cjs.js');
+var plugin = require('./plugin.cjs.js');
 
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
-var express__default = /*#__PURE__*/_interopDefaultCompat(express);
-var Router__default = /*#__PURE__*/_interopDefaultCompat(Router);
 
-const MIN_KWIRTH_VERSION = "0.4.63";
-class KwirthStaticData {
-  static clusterKwirthData = /* @__PURE__ */ new Map();
-  static latestVersions;
-}
-
-const loadNamespacePermissions = (channelConfig, logger) => {
-  let namespacePermissions = [];
-  if (channelConfig.has("namespacePermissions")) {
-    logger.info(`  Namespace permisson evaluation will be performed.`);
-    let permNamespaces = channelConfig.getOptionalConfigArray("namespacePermissions");
-    for (let ns of permNamespaces) {
-      let namespace = ns.keys()[0];
-      let identityRefs = ns.getStringArray(namespace);
-      identityRefs = identityRefs.map((g) => g.toLowerCase());
-      namespacePermissions.push({ namespace, identityRefs });
-    }
-  } else {
-    logger.info(`  No namespace restrictions.`);
-    namespacePermissions = [];
-  }
-  return namespacePermissions;
-};
-const loadPodRules = (config, category) => {
-  let rules = [];
-  for (let rule of config.getConfigArray(category)) {
-    let podsStringArray = rule.getOptionalStringArray("pods") || [".*"];
-    let podsRegexArray = [];
-    for (let expr of podsStringArray) {
-      podsRegexArray.push(new RegExp(expr));
-    }
-    let refsStringArray = rule.getOptionalStringArray("refs") || [".*"];
-    let refsRegexArray = [];
-    for (let expr of refsStringArray) {
-      refsRegexArray.push(new RegExp(expr));
-    }
-    let prr = {
-      pods: podsRegexArray,
-      refs: refsRegexArray
-    };
-    rules.push(prr);
-  }
-  return rules;
-};
-const loadPodPermissions = (channelConfig, logger) => {
-  let clusterPodPermissions = [];
-  if (channelConfig.has("podPermissions")) {
-    logger.info(`  Pod permisson evaluation will be performed.`);
-    let namespaceList = channelConfig.getConfigArray("podPermissions");
-    for (let ns of namespaceList) {
-      let namespaceName = ns.keys()[0];
-      let podPermissions = { namespace: namespaceName };
-      if (ns.getConfig(namespaceName).has("allow")) {
-        podPermissions.allow = loadPodRules(ns.getConfig(namespaceName), "allow");
-        if (ns.getConfig(namespaceName).has("except")) podPermissions.except = loadPodRules(ns.getConfig(namespaceName), "except");
-        if (ns.getConfig(namespaceName).has("deny")) podPermissions.deny = loadPodRules(ns.getConfig(namespaceName), "deny");
-        if (ns.getConfig(namespaceName).has("unless")) podPermissions.unless = loadPodRules(ns.getConfig(namespaceName), "unless");
-      } else {
-        podPermissions.allow = [];
-        podPermissions.allow.push({
-          pods: [new RegExp(".*")],
-          refs: [new RegExp(".*")]
-        });
-      }
-      clusterPodPermissions.push(podPermissions);
-    }
-  } else {
-    logger.info(`  No pod permissions will be applied.`);
-  }
-  return clusterPodPermissions;
-};
-const addChannelPermissions = (channel, logger, cluster, kdata) => {
-  let keyname = "kwirth" + channel;
-  let keyCamelName = "kwirth" + channel[0].toUpperCase() + channel.substring(1);
-  if (cluster.has(keyCamelName)) keyname = keyCamelName;
-  if (cluster.has(keyname)) {
-    logger.info(`Load permissions for channel ${channel} (config: ${keyname}).`);
-    let configChannel = cluster.getConfig(keyname);
-    if (configChannel.has("namespacePermissions")) {
-      logger.info(`  Loading namespace permissions.`);
-      kdata.namespacePermissions.set(channel, loadNamespacePermissions(configChannel, logger));
-    } else {
-      logger.info(`  No namespace permissions.`);
-      kdata.namespacePermissions.set(channel, []);
-    }
-    if (configChannel.has("podPermissions")) {
-      logger.info(`  Loading pod permissions.`);
-      kdata.podPermissions.set(channel, loadPodPermissions(configChannel, logger));
-    } else {
-      logger.info(`  No pod permissions.`);
-      kdata.podPermissions.set(channel, []);
-    }
-  } else {
-    logger.info(`Cluster ${cluster.getString("name")} will have no channel '${channel}' restrictions.`);
-    kdata.namespacePermissions.set(channel, []);
-    kdata.podPermissions.set(channel, []);
-  }
-};
-const loadClusters = async (logger, config) => {
-  KwirthStaticData.clusterKwirthData.clear();
-  let locatingMethods = config.getConfigArray("kubernetes.clusterLocatorMethods");
-  for (let method of locatingMethods) {
-    let clusters = method.getConfigArray("clusters");
-    for (let cluster of clusters) {
-      let name = cluster.getString("name");
-      if (cluster.has("kwirthHome") && cluster.has("kwirthApiKey")) {
-        let kwirthHome = cluster.getOptionalString("kwirthHome");
-        let kwirthApiKey = cluster.getOptionalString("kwirthApiKey");
-        let title = cluster.has("title") ? cluster.getString("title") : "No name";
-        let kwirthClusterData = {
-          name,
-          kwirthHome,
-          kwirthApiKey,
-          kwirthData: {
-            version: "",
-            clusterName: "",
-            inCluster: false,
-            namespace: "",
-            deployment: "",
-            lastVersion: "",
-            clusterType: kwirthCommon.ClusterTypeEnum.KUBERNETES,
-            metricsInterval: 0,
-            channels: []
-          },
-          title,
-          namespacePermissions: /* @__PURE__ */ new Map(),
-          podPermissions: /* @__PURE__ */ new Map(),
-          enabled: false
-        };
-        logger.info(`Kwirth for ${name} is located at ${kwirthClusterData.kwirthHome}. Testing connection...`);
-        let enableCluster = false;
-        try {
-          let response = await fetch(kwirthClusterData.kwirthHome + "/config/info");
-          try {
-            let data = await response.text();
-            try {
-              let kwirthData = JSON.parse(data);
-              logger.info(`Kwirth info at cluster '${kwirthClusterData.name}': ${JSON.stringify(kwirthData)}`);
-              kwirthClusterData.kwirthData = kwirthData;
-              if (kwirthCommon.versionGreatOrEqualThan(kwirthData.version, MIN_KWIRTH_VERSION)) {
-                enableCluster = true;
-              } else {
-                logger.error(`Unsupported Kwirth version on cluster '${name}' (${title}) [${kwirthData.version}]. Min version is ${MIN_KWIRTH_VERSION}`);
-              }
-            } catch (err) {
-              logger.error(`Kwirth at cluster ${kwirthClusterData.name} returned errors: ${err}`);
-              logger.info("Returned data is:");
-              logger.info(data);
-              kwirthClusterData.kwirthData = {
-                version: "0.0.0",
-                clusterName: "unknown",
-                inCluster: false,
-                namespace: "unknown",
-                deployment: "unknown",
-                lastVersion: "0.0.0",
-                clusterType: kwirthCommon.ClusterTypeEnum.KUBERNETES,
-                metricsInterval: 0,
-                channels: []
-              };
-            }
-          } catch (err) {
-            logger.warn(`Error parsing version response from cluster '${kwirthClusterData.name}': ${err}`);
-          }
-        } catch (err) {
-          logger.info(`Kwirth access error: ${err}.`);
-          logger.warn(`Kwirth home URL (${kwirthClusterData.kwirthHome}) at cluster '${kwirthClusterData.name}' cannot be accessed right now.`);
-        }
-        if (enableCluster) {
-          [
-            kwirthCommon.InstanceMessageChannelEnum.LOG,
-            kwirthCommon.InstanceMessageChannelEnum.ALERT,
-            "fileman",
-            kwirthCommon.InstanceMessageChannelEnum.METRICS
-          ].map((channel) => addChannelPermissions(channel, logger, cluster, kwirthClusterData));
-          KwirthStaticData.clusterKwirthData.set(name, kwirthClusterData);
-        } else {
-          logger.warn(`Cluster ${name} will be disabled`);
-        }
-      } else {
-        logger.warn(`Cluster ${name} has no Kwirth information (kwirthHome and kwirthApiKey are missing).`);
-      }
-    }
-  }
-  logger.info("Kwirth static data has been set including following clusters:");
-  for (let c of KwirthStaticData.clusterKwirthData.keys()) {
-    logger.info("  " + c);
-  }
-  for (let c of KwirthStaticData.clusterKwirthData.keys()) {
-    console.log(KwirthStaticData.clusterKwirthData.get(c));
-  }
-};
-const loadKwirthInfo = async (logger) => {
-  try {
-    let pkb = await (await fetch("https://registry.npmjs.org/@jfvilas/plugin-kwirth-backend")).json();
-    let pkl = await (await fetch("https://registry.npmjs.org/@jfvilas/plugin-kwirth-log")).json();
-    let pkm = await (await fetch("https://registry.npmjs.org/@jfvilas/plugin-kwirth-metrics")).json();
-    let hubResp = await (await fetch("https://hub.docker.com/v2/repositories/jfvilasoutlook/kwirth/tags?page_size=25&page=1&ordering=last_updated&name=")).json();
-    KwirthStaticData.latestVersions = {
-      ["plugin-kwirth-backend"]: pkb["dist-tags"].latest,
-      ["plugin-kwirth-log"]: pkl["dist-tags"].latest,
-      ["plugin-kwirth-metrics"]: pkm["dist-tags"].latest,
-      kwirth: hubResp.results[0].name
-    };
-    logger.info("Latest Kwirth-related artifacts versions are:");
-    logger.info(JSON.stringify(KwirthStaticData.latestVersions));
-  } catch (err) {
-    console.log(err);
-    logger.warn("Oops! We couldn't fetch the latest version info. Don't worry \u2014 it's not critical. Kwirth's still here for you.");
-  }
-};
-
-const checkNamespaceAccess = (channel, cluster, podData, userEntityRef, userGroups) => {
-  let allowedToNamespace = false;
-  let namespacePermissions = KwirthStaticData.clusterKwirthData.get(cluster.name)?.namespacePermissions;
-  if (namespacePermissions?.has(channel)) {
-    let rule = namespacePermissions?.get(channel).find((ns) => ns.namespace === podData.namespace);
-    if (rule) {
-      if (rule.identityRefs.includes(userEntityRef.toLowerCase())) {
-        allowedToNamespace = true;
-      } else {
-        var groupResult = rule.identityRefs.some((identityRef) => userGroups.includes(identityRef));
-        if (groupResult) {
-          allowedToNamespace = true;
-        }
-      }
-    } else {
-      allowedToNamespace = true;
-    }
-  } else {
-    console.log(`Invalid channel: ${channel}`);
-  }
-  return allowedToNamespace;
-};
-const checkPodPermissionRule = (ppr, entityName, userEntityRef, userGroups) => {
-  var refMatch = false;
-  for (var podNameRegex of ppr.pods) {
-    if (podNameRegex.test(entityName)) {
-      for (var refRegex of ppr.refs) {
-        refMatch = refRegex.test(userEntityRef.toLowerCase());
-        if (refMatch) {
-          break;
-        } else {
-          refMatch = userGroups.some((g) => refRegex.test(g));
-          if (refMatch) {
-            break;
-          }
-        }
-      }
-    }
-    if (refMatch) break;
-  }
-  return refMatch;
-};
-const getPodPermissionSet = (channel, cluster) => {
-  if (cluster.podPermissions.has(channel)) {
-    return cluster.podPermissions.get(channel);
-  } else {
-    console.log(`Invalid channel ${channel} for permission set`);
-    return void 0;
-  }
-};
-const checkPodAccess = (reqPod, podPermissionSet, entityName, userEntityRef, userGroups) => {
-  for (var podPermission of podPermissionSet.filter((pp) => pp.namespace === reqPod.namespace)) {
-    if (podPermission.allow) {
-      var allowMatches = false;
-      var exceptMatches = false;
-      for (var prr of podPermission.allow) {
-        allowMatches = checkPodPermissionRule(prr, entityName, userEntityRef, userGroups);
-      }
-      if (allowMatches) {
-        if (podPermission.except) {
-          for (var prr of podPermission.except) {
-            exceptMatches = checkPodPermissionRule(prr, entityName, userEntityRef, userGroups);
-            if (exceptMatches) {
-              break;
-            }
-          }
-        }
-      }
-      if (allowMatches && !exceptMatches) {
-        if (podPermission.deny) {
-          var denyMatches = false;
-          var unlessMatches = false;
-          for (var prr of podPermission.deny) {
-            denyMatches = checkPodPermissionRule(prr, entityName, userEntityRef, userGroups);
-            if (denyMatches) {
-              break;
-            }
-          }
-          if (denyMatches && podPermission.unless) {
-            for (var prr of podPermission.unless) {
-              unlessMatches = checkPodPermissionRule(prr, entityName, userEntityRef, userGroups);
-              if (unlessMatches) {
-                break;
-              }
-            }
-          }
-          if (!denyMatches || denyMatches && unlessMatches) {
-            return true;
-          }
-        } else {
-          return true;
-        }
-      }
-    } else {
-      return true;
-    }
-  }
-  return false;
-};
-
-const VERSION = "0.13.5";
-
-async function createRouter(options) {
-  const { configSvc, loggerSvc, userInfoSvc, authSvc, httpAuthSvc, discoverySvc } = options;
-  loggerSvc.info("Loading static config");
-  if (!configSvc.has("kubernetes.clusterLocatorMethods")) {
-    loggerSvc.error(`Kwirth will not start, there is no 'clusterLocatorMethods' defined in app-config.`);
-    throw new Error("Kwirth backend will not be available.");
-  }
-  try {
-    loadClusters(loggerSvc, configSvc);
-    loadKwirthInfo(loggerSvc);
-  } catch (err) {
-    let txt = `Errors detected reading static configuration: ${err}`;
-    loggerSvc.error(txt);
-    throw new Error(txt);
-  }
-  if (configSvc.subscribe) {
-    configSvc.subscribe(() => {
-      try {
-        loggerSvc.warn("Change detected on app-config, Kwirth will update config.");
-        loadClusters(loggerSvc, configSvc);
-      } catch (err) {
-        loggerSvc.error(`Errors detected reading new configuration: ${err}`);
-      }
-    });
-  } else {
-    loggerSvc.info("Kwirth cannot subscribe to config changes.");
-  }
-  const router = Router__default.default();
-  router.use(express__default.default.json());
-  const createAuthFetchApi = (token) => {
-    return {
-      fetch: async (input, init) => {
-        init = init || {};
-        init.headers = {
-          ...init.headers,
-          Authorization: `Bearer ${token}`
-        };
-        return fetch(input, init);
-      }
-    };
-  };
-  const getValidClustersFromEntity = async (entity) => {
-    let clusterList = [];
-    for (const clusterName of KwirthStaticData.clusterKwirthData.keys()) {
-      let url = KwirthStaticData.clusterKwirthData.get(clusterName)?.kwirthHome;
-      let apiKeyStr = KwirthStaticData.clusterKwirthData.get(clusterName)?.kwirthApiKey;
-      let title = KwirthStaticData.clusterKwirthData.get(clusterName)?.title;
-      let clusterVersion = KwirthStaticData.clusterKwirthData.get(clusterName)?.kwirthData.version || "0.0.0";
-      let queryUrl = void 0;
-      if (entity.metadata.annotations["backstage.io/kubernetes-id"]) {
-        queryUrl = url + `/managecluster/find?label=backstage.io%2fkubernetes-id&entity=${entity.metadata.annotations["backstage.io/kubernetes-id"]}&type=pod&data=containers`;
-      } else if (entity.metadata.annotations["backstage.io/kubernetes-label-selector"]) {
-        if (kwirthCommon.versionGreaterThan(clusterVersion, "0.4.40")) {
-          let escapedLabelSelector = encodeURIComponent(entity.metadata.annotations["backstage.io/kubernetes-label-selector"]);
-          queryUrl = url + `/managecluster/find?labelselector=${escapedLabelSelector}&type=pod&data=containers`;
-        } else {
-          loggerSvc.error(`Version ${clusterVersion} from cluster ${clusterName} is not valid for using ${pluginKwirthCommon.ANNOTATION_BACKSTAGE_KUBERNETES_LABELSELECTOR}`);
-          clusterList.push({ name: clusterName, url, title, pods: [], accessKeys: /* @__PURE__ */ new Map() });
-          continue;
-        }
-      } else {
-        loggerSvc.error("Received request without labelid/labelselector");
-        clusterList.push({ name: clusterName, url, title, pods: [], accessKeys: /* @__PURE__ */ new Map() });
-        continue;
-      }
-      try {
-        let fetchResp = await fetch(queryUrl, { headers: { "Authorization": "Bearer " + apiKeyStr } });
-        if (fetchResp.status === 200) {
-          let jsonResp = await fetchResp.json();
-          console.log("jsonResp");
-          console.log(jsonResp);
-          if (jsonResp) {
-            let podData = {
-              name: clusterName,
-              url,
-              title,
-              pods: jsonResp,
-              accessKeys: /* @__PURE__ */ new Map()
-            };
-            clusterList.push(podData);
-          } else {
-            loggerSvc.warn(`Invalid data received from cluster ${clusterName}`);
-            clusterList.push({ name: clusterName, url, title, pods: [], accessKeys: /* @__PURE__ */ new Map() });
-          }
-        } else {
-          loggerSvc.warn(`Invalid response from cluster ${clusterName}: ${fetchResp.status}`);
-          let text = await fetchResp.text();
-          if (text) loggerSvc.warn(text);
-          clusterList.push({ name: clusterName, url, title, pods: [], accessKeys: /* @__PURE__ */ new Map() });
-        }
-      } catch (err) {
-        loggerSvc.warn(`Cannot access cluster ${clusterName} (URL: ${queryUrl}): ${err}`);
-        clusterList.push({ name: clusterName, url, title, pods: [], accessKeys: /* @__PURE__ */ new Map() });
-      }
-    }
-    return clusterList;
-  };
-  const createAccessKey = async (reqScope, cluster, reqPods, userName) => {
-    let resources = reqPods.map((podData) => `${reqScope}:${podData.namespace}::${podData.name}:`).join(";");
-    let kwirthHome = KwirthStaticData.clusterKwirthData.get(cluster.name)?.kwirthHome;
-    let kwirthApiKey = KwirthStaticData.clusterKwirthData.get(cluster.name)?.kwirthApiKey;
-    let payload = {
-      description: `Backstage API key for user ${userName}`,
-      expire: Date.now() + 60 * 60 * 1e3,
-      days: 1,
-      accessKey: {
-        id: "",
-        type: "bearer",
-        resources
-      }
-    };
-    let fetchResp = await fetch(kwirthHome + "/key", { method: "POST", body: JSON.stringify(payload), headers: { "Content-Type": "application/json", Authorization: "Bearer " + kwirthApiKey } });
-    if (fetchResp.status === 200) {
-      let data = await fetchResp.json();
-      return data.accessKey;
-    } else {
-      loggerSvc.warn(`Invalid response asking for a key from cluster ${cluster.name}: ${fetchResp.status}`);
-      return void 0;
-    }
-  };
-  const addAccessKeys = async (channel, reqScope, foundClusters, entityName, userEntityRef, userGroups) => {
-    if (!reqScope) {
-      loggerSvc.info(`Invalid scope requested: ${reqScope}`);
-      return;
-    }
-    let principal = userEntityRef.split(":")[1];
-    let username = principal.split("/")[1];
-    for (let foundCluster of foundClusters) {
-      let podList = [];
-      if (!KwirthStaticData.clusterKwirthData.get(foundCluster.name)?.kwirthData.channels.some((c) => c.id === channel)) {
-        loggerSvc.warn(`Cluster ${foundCluster.name} does not implement channel ${channel} (requested scope: ${reqScope})`);
-        continue;
-      }
-      for (let podData of foundCluster.pods) {
-        let allowedToNamespace = checkNamespaceAccess(channel, foundCluster, podData, userEntityRef, userGroups);
-        if (allowedToNamespace) {
-          let clusterDef = KwirthStaticData.clusterKwirthData.get(foundCluster.name);
-          let podPermissionSet = getPodPermissionSet(channel, clusterDef);
-          if (!podPermissionSet) {
-            loggerSvc.warn(`Pod permission set not found: ${channel}`);
-            continue;
-          }
-          let namespaceRestricted = podPermissionSet.some((pp) => pp.namespace === podData.namespace);
-          if (!namespaceRestricted || checkPodAccess(podData, podPermissionSet, entityName, userEntityRef, userGroups)) {
-            podList.push(podData);
-          }
-        }
-      }
-      if (podList.length > 0) {
-        let accessKey = await createAccessKey(reqScope, foundCluster, podList, username);
-        if (accessKey) foundCluster.accessKeys.set(reqScope, accessKey);
-      } else {
-        loggerSvc.info(`No pods on podList for '${reqScope}' on channel '${channel}' in cluster '${foundCluster.name}' for searching for entity: '${entityName}'`);
-      }
-    }
-  };
-  const getUserGroups = async (userInfo) => {
-    const { token } = await authSvc.getPluginRequestToken({
-      onBehalfOf: await authSvc.getOwnServiceCredentials(),
-      targetPluginId: "catalog"
-    });
-    const catalogClient$1 = new catalogClient.CatalogClient({
-      discoveryApi: discoverySvc,
-      fetchApi: createAuthFetchApi(token)
-    });
-    const entity = await catalogClient$1.getEntityByRef(userInfo.userEntityRef);
-    let userGroupsRefs = [];
-    if (entity?.spec.memberOf) userGroupsRefs = entity?.spec.memberOf;
-    return userGroupsRefs;
-  };
-  const processVersion = async (_req, res) => {
-    res.status(200).send({ version: VERSION });
-  };
-  const processInfo = async (_req, res) => {
-    res.status(200).send(
-      KwirthStaticData.latestVersions
-    );
-  };
-  const processAccess = async (req, res) => {
-    if (!req.query["scopes"] || !req.query["channel"]) {
-      res.status(400).send(`'scopes' and 'channel' are required`);
-      return;
-    }
-    let reqScopes = req.query["scopes"].toString().split(",");
-    let reqChannel = req.query["channel"]?.toString();
-    const credentials = await httpAuthSvc.credentials(req, { allow: ["user"] });
-    const userInfo = await userInfoSvc.getUserInfo(credentials);
-    let userGroupsRefs = await getUserGroups(userInfo);
-    loggerSvc.info(`Checking reqScopes '${req.query["scopes"]}' scopes for working with pod: '${req.body.metadata.namespace + "/" + req.body.metadata.name}' for user '${userInfo.userEntityRef}'`);
-    let foundClusters = await getValidClustersFromEntity(req.body);
-    for (let reqScopeStr of reqScopes) {
-      let reqScope = reqScopeStr;
-      await addAccessKeys(reqChannel, reqScope, foundClusters, req.body.metadata.name, userInfo.userEntityRef, userGroupsRefs);
-      if (reqScope === kwirthCommon.InstanceConfigScopeEnum.STREAM) {
-        for (let cluster of foundClusters) {
-          let accessKey = cluster.accessKeys.get(kwirthCommon.InstanceConfigScopeEnum.STREAM);
-          if (accessKey) {
-            let url = cluster.url + "/metrics";
-            let auth = "Bearer " + kwirthCommon.accessKeySerialize(accessKey);
-            let fetchResp = await fetch(url, { headers: { "Authorization": auth } });
-            try {
-              let data = await fetchResp.json();
-              cluster.metrics = data;
-            } catch (err) {
-              loggerSvc.error(`Cannot get metrics on cluster ${cluster.name}: ` + err);
-            }
-          }
-        }
-      }
-    }
-    for (let c of foundClusters) {
-      c.accessKeys = JSON.stringify(Array.from(c.accessKeys.entries()));
-    }
-    res.status(200).send(foundClusters);
-  };
-  router.post(["/access"], (req, res) => {
-    processAccess(req, res);
-  });
-  router.get(["/version"], (req, res) => {
-    processVersion(req, res);
-  });
-  router.get(["/info"], (req, res) => {
-    processInfo(req, res);
-  });
-  return router;
-}
-
-const kwirthPlugin = backendPluginApi.createBackendPlugin({
-  pluginId: "kwirth",
-  register(env) {
-    env.registerInit({
-      deps: {
-        discovery: backendPluginApi.coreServices.discovery,
-        config: backendPluginApi.coreServices.rootConfig,
-        logger: backendPluginApi.coreServices.logger,
-        auth: backendPluginApi.coreServices.auth,
-        httpAuth: backendPluginApi.coreServices.httpAuth,
-        httpRouter: backendPluginApi.coreServices.httpRouter,
-        userInfo: backendPluginApi.coreServices.userInfo
-      },
-      async init({ discovery, config, httpRouter, logger, auth, httpAuth, userInfo }) {
-        httpRouter.use(
-          await createRouter({
-            discoverySvc: discovery,
-            configSvc: config,
-            loggerSvc: logger,
-            authSvc: auth,
-            httpAuthSvc: httpAuth,
-            userInfoSvc: userInfo
-          })
-        );
-      }
-    });
-  }
-});
-
-exports.createRouter = createRouter;
-exports.default = kwirthPlugin;
+exports.createRouter = router.createRouter;
+exports.default = plugin.kwirthPlugin;
 //# sourceMappingURL=index.cjs.js.map