@interopio/bridge 0.0.1-alpha → 0.0.3-beta

package/dist/main.js

@@ -0,0 +1,2139 @@
+// src/utils/uuid.ts
+import { nanoid } from "nanoid";
+function newUUID() {
+  return nanoid();
+}
+
+// src/utils/network.ts
+import { networkInterfaces } from "node:os";
+import { ADDRCONFIG } from "node:dns";
+import { lookup, lookupService } from "node:dns/promises";
+
+// src/utils/internal/IpAddressUtil.ts
+var DOT = ".".charCodeAt(0);
+var COLON = ":".charCodeAt(0);
+function textToNumericFormatV4(address) {
+  const result = new Uint8Array(4);
+  const len = address.length;
+  if (len == 0 || len > 15) {
+    return;
+  }
+  let currentValue = 0;
+  let currentByte = 0;
+  let newByte = true;
+  for (let i = 0; i < len; i++) {
+    const ch = address.charCodeAt(i);
+    if (ch === DOT) {
+      if (newByte || currentValue < 0 || currentValue > 255 || currentByte > 3) {
+        return;
+      }
+      result[currentByte++] = currentValue & 255;
+      currentValue = 0;
+      newByte = true;
+    } else {
+      const digit = ch - 48;
+      if (digit < 0) {
+        return;
+      }
+      currentValue *= 10;
+      currentValue += digit;
+      newByte = false;
+    }
+  }
+  if (newByte || currentValue < 0 || currentValue >= 1 << (4 - currentByte) * 8) {
+    return;
+  }
+  switch (currentByte) {
+    case 0:
+      result[0] = currentValue >> 24 & 255;
+    //fall through
+    case 1:
+      result[1] = currentValue >> 16 & 255;
+    //fall through
+    case 2:
+      result[2] = currentValue >> 8 & 255;
+    //fall through
+    case 3:
+      result[3] = currentValue >> 0 & 255;
+  }
+  return result;
+}
+
+// src/utils/network.ts
+import { readFileSync } from "node:fs";
+var IpAddress = class {
+  address;
+  family;
+  _hostname;
+  constructor(host, address, family) {
+    this._hostname = host;
+    this.address = address;
+    this.family = family;
+  }
+  get addressBytes() {
+    if (this.family === 4) {
+      return textToNumericFormatV4(this.address);
+    }
+  }
+  async getHost() {
+    if (!this._hostname) {
+      this._hostname = (await lookupService(this.address, 0)).hostname;
+    }
+    return this._hostname;
+  }
+  async getIpAddress(nonLoopback = false) {
+    const hints = nonLoopback ? ADDRCONFIG : void 0;
+    return await lookup(this.address, { family: this.family, hints });
+  }
+};
+function isLoopback(address) {
+  return address.family === 4 && address.address.startsWith("127.") || address.family === 6 && address.address.startsWith("::1");
+}
+async function getByName(host) {
+  const { address, family } = await lookup(host, { family: 4 });
+  if (family !== 4 && family !== 6) {
+    throw new Error("unexpected address type");
+  }
+  return new IpAddress(void 0, address, family);
+}
+function getNetworkInterfaces() {
+  return Object.entries(networkInterfaces()).map(([name, addresses]) => {
+    return {
+      name,
+      loopback: addresses.some((info) => info.internal),
+      addresses: addresses.map((info) => {
+        return new IpAddress(void 0, info.address, info.family === "IPv6" ? 6 : 4);
+      })
+    };
+  });
+}
+function soMaxConn() {
+  let somaxconn;
+  if (process.platform === "win32") {
+    somaxconn = 200;
+  } else if (process.platform === "darwin") {
+    somaxconn = 128;
+  } else {
+    somaxconn = 4096;
+  }
+  try {
+    somaxconn = parseInt(readFileSync("/proc/sys/net/core/somaxconn").toString());
+  } catch (error) {
+  }
+  return somaxconn;
+}
+var SOMAXCONN = soMaxConn();
+
+// src/cluster/Address.ts
+async function toIpAddress(address) {
+  return await getByName(scopedHost(address));
+}
+async function fromHostname(hostname, port) {
+  return new AddressImpl(hostname, await getByName(hostname), port);
+}
+function fromIpAddress(address, port) {
+  return new AddressImpl(void 0, address, port);
+}
+var AddressImpl = class {
+  type;
+  host;
+  port;
+  address;
+  constructor(hostname, ipAddress, port) {
+    const type = ipAddress.family;
+    if (type !== 4 && type !== 6) {
+      throw new Error("unexpected address type");
+    }
+    this.type = type;
+    this.host = hostname ?? ipAddress.address;
+    this.port = port;
+    this.address = ipAddress;
+  }
+};
+function scopedHost(address) {
+  if (address.type === 6) {
+    return `[${address.host}]`;
+  }
+  return address.host;
+}
+
+// src/config/Properties.ts
+var BOOLEAN = new class {
+  convert(value) {
+    if (typeof value === "boolean") {
+      return value;
+    } else if (typeof value === "string") {
+      return value.toLowerCase() === "true";
+    }
+    throw new Error("Cannot convert value to boolean: " + value);
+  }
+}();
+var STRING = new class {
+  convert(value) {
+    if (value === void 0) {
+      throw new Error("Cannot convert undefined ");
+    }
+    return String(value);
+  }
+}();
+var NUMBER = new class {
+  convert(value) {
+    if (value === void 0) {
+      throw new Error("Cannot convert undefined ");
+    }
+    if (typeof value === "object") {
+      throw new Error("Cannot convert object/array to number: " + value);
+    }
+    return Number(value);
+  }
+}();
+function property(name, converter) {
+  return { key: name, optional: true, converter };
+}
+
+// src/config/DiscoveryConfig.ts
+var DefaultDiscoveryConfig = class {
+  discoveryStrategyConfigs = [];
+  discoveryServiceFactory;
+  get enabled() {
+    return this.discoveryStrategyConfigs.length > 0;
+  }
+};
+
+// src/logging.ts
+import { IOGateway } from "@interopio/gateway";
+function getLogger(name) {
+  return IOGateway.Logging.getLogger(`gateway.bridge.${name}`);
+}
+
+// src/kubernetes/KubernetesDiscoveryStrategyFactory.ts
+import { stat } from "node:fs/promises";
+import { lookup as lookup2 } from "node:dns/promises";
+
+// src/kubernetes/KubernetesConfig.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+
+// src/discovery/settings.ts
+function getProperty(prefix, property2) {
+  let s = prefix;
+  if (!s.endsWith(".")) {
+    s += ".";
+  }
+  return s + property2.key;
+}
+function readProperty(prefix, property2) {
+  if (prefix) {
+    const p = getProperty(prefix, property2);
+    const v = process.env[p];
+    return v;
+  }
+}
+function getOrUndefined(properties, prefix, property2) {
+  return getOrDefault(properties, prefix, property2);
+}
+function getOrDefault(properties, prefix, property2, defaultValue) {
+  if (property2 === void 0) {
+    return defaultValue;
+  }
+  let value = readProperty(prefix, property2);
+  if (value === void 0) {
+    value = properties[property2.key];
+  }
+  if (value === void 0) {
+    return defaultValue;
+  }
+  return value;
+}
+
+// src/kubernetes/KubernetesProperties.ts
+var KUBERNETES_ENV_PREFIX = "io.bridge.kubernetes";
+var SERVICE_DNS = property("service-dns", STRING);
+var SERVICE_NAME = property("service-name", STRING);
+var SERVICE_LABEL_NAME = property("service-label-name", STRING);
+var SERVICE_LABEL_VALUE = property("service-label-value", STRING);
+var NAMESPACE = property("namespace", STRING);
+var POD_LABEL_NAME = property("pod-label-name", STRING);
+var POD_LABEL_VALUE = property("pod-label-value", STRING);
+var EXPOSE_EXTERNALLY = property("expose-externally", BOOLEAN);
+var SERVICE_PER_POD_LABEL_NAME = property("service-per-pod-label-name", STRING);
+var SERVICE_PER_POD_LABEL_VALUE = property("service-per-pod-label-value", STRING);
+var RESOLVE_NOT_READY_ADDRESSES = property("resolve-not-ready-addresses", BOOLEAN);
+var KUBERNETES_MASTER_URL = property("kubernetes-master", STRING);
+var KUBERNETES_API_TOKEN = property("api-token", STRING);
+var SERVICE_PORT = property("service-port", NUMBER);
+
+// src/kubernetes/KubernetesConfig.ts
+function readFileContents(fileName) {
+  return readFileSync2(fileName, "utf-8").toString();
+}
+var KubernetesConfig = class {
+  serviceDns;
+  serviceName;
+  serviceLabelName;
+  serviceLabelValue;
+  namespace;
+  podLabelName;
+  podLabelValue;
+  resolveNotReadyAddresses;
+  exposeExternallyMode;
+  servicePerPodLabelName;
+  servicePerPodLabelValue;
+  kubernetesMasterUrl;
+  kubernetesApiToken;
+  servicePort;
+  fileContentsReader;
+  tokenProvider;
+  constructor(properties, fileContentsReader = readFileContents) {
+    this.fileContentsReader = fileContentsReader;
+    this.serviceDns = getOrDefault(properties, KUBERNETES_ENV_PREFIX, SERVICE_DNS);
+    this.serviceName = getOrDefault(properties, KUBERNETES_ENV_PREFIX, SERVICE_NAME);
+    this.serviceLabelName = getOrUndefined(properties, KUBERNETES_ENV_PREFIX, SERVICE_LABEL_NAME);
+    this.serviceLabelValue = getOrDefault(properties, KUBERNETES_ENV_PREFIX, SERVICE_LABEL_VALUE, "true");
+    this.resolveNotReadyAddresses = getOrDefault(properties, KUBERNETES_ENV_PREFIX, RESOLVE_NOT_READY_ADDRESSES, true);
+    this.podLabelName = getOrUndefined(properties, KUBERNETES_ENV_PREFIX, POD_LABEL_NAME);
+    this.podLabelValue = getOrUndefined(properties, KUBERNETES_ENV_PREFIX, POD_LABEL_VALUE);
+    this.exposeExternallyMode = this.getExposeExternallyMode(properties);
+    this.servicePerPodLabelName = getOrUndefined(properties, KUBERNETES_ENV_PREFIX, SERVICE_PER_POD_LABEL_NAME);
+    this.servicePerPodLabelValue = getOrUndefined(properties, KUBERNETES_ENV_PREFIX, SERVICE_PER_POD_LABEL_VALUE);
+    this.kubernetesMasterUrl = getOrDefault(properties, KUBERNETES_ENV_PREFIX, KUBERNETES_MASTER_URL, "https://kubernetes.default.svc");
+    this.tokenProvider = this.buildTokenProvider(properties);
+    this.servicePort = getOrDefault(properties, KUBERNETES_ENV_PREFIX, SERVICE_PORT, 0);
+    this.namespace = this.getNamespaceWithFallbacks(properties);
+  }
+  getExposeExternallyMode(properties) {
+    const exposeExternally = getOrUndefined(properties, KUBERNETES_ENV_PREFIX, EXPOSE_EXTERNALLY);
+    if (exposeExternally === void 0) {
+      return "auto";
+    } else if (exposeExternally) {
+      return "enabled";
+    } else {
+      return "disabled";
+    }
+  }
+  getNamespaceWithFallbacks(properties) {
+    let namespace = getOrDefault(properties, KUBERNETES_ENV_PREFIX, NAMESPACE);
+    if (!namespace) {
+      namespace = process.env["KUBERNETES_NAMESPACE"];
+    }
+    if (!namespace && this.mode === "kubernetes-api") {
+      namespace = this.readNamespace();
+    }
+    return namespace;
+  }
+  buildTokenProvider(properties) {
+    const apiToken = getOrUndefined(properties, KUBERNETES_ENV_PREFIX, KUBERNETES_API_TOKEN);
+    if (!apiToken && this.mode === "kubernetes-api") {
+      return () => readFileContents("/var/run/secrets/kubernetes.io/serviceaccount/token");
+    } else {
+      return () => apiToken;
+    }
+  }
+  readNamespace() {
+    return this.fileContentsReader("/var/run/secrets/kubernetes.io/serviceaccount/namespace");
+  }
+  get mode() {
+    if (this.serviceDns) {
+      return "dns-lookup";
+    }
+    return "kubernetes-api";
+  }
+  toString() {
+    return "KubernetesConfig: {service-dns: " + this.serviceDns + ", service-name: " + this.serviceName + ", service-port: " + this.servicePort + ", service-label-name: " + this.serviceLabelName + ", service-label-value: " + this.serviceLabelValue + ", namespace: " + this.namespace + ", pod-label-name: " + this.podLabelName + ", pod-label-value: " + this.podLabelValue + ", resolve-not-ready-addresses: " + this.resolveNotReadyAddresses + ", expose-externally-mode: " + this.exposeExternallyMode + ", service-per-pod-label-name: " + this.servicePerPodLabelName + ", service-per-pod-label-value: " + this.servicePerPodLabelValue + ", kubernetes-master-url: " + this.kubernetesMasterUrl + "}";
+  }
+};
+
+// src/kubernetes/KubernetesApiProvider.ts
+var KubernetesApiEndpointSlicesProvider = class {
+  getEndpointsByServiceLabelUrlString(kubernetesMaster, namespace, param) {
+    return `${kubernetesMaster}/apis/discovery.k8s.io/v1/namespaces/${namespace}/endpointslices?${param}`;
+  }
+  getEndpointsByNameUrlString(kubernetesMaster, namespace, endpointName) {
+    return `${kubernetesMaster}/apis/discovery.k8s.io/v1/namespaces/${namespace}/endpointslices?labelSelector=kubernetes.io/service-name=${endpointName}`;
+  }
+  parseEndpoints(param) {
+    const endpoints = new Array();
+    for (const item of param.items) {
+      endpoints.push(...this.parseEndpointSlices(item));
+    }
+    return endpoints;
+  }
+  parseEndpointSlices(item) {
+    const addresses = new Array();
+    const endpointPort = this.extractPort(item);
+    for (const endpoint of item.endpoints) {
+      const ready = endpoint.conditions.ready;
+      for (const address of endpoint.addresses) {
+        addresses.push(new Endpoint(new EndpointAddress({ ip: address, port: endpointPort }), void 0, ready));
+      }
+    }
+    return addresses;
+  }
+  extractPort(item) {
+    for (const port of item.ports) {
+      const bridgeServicePort = port.name;
+      if (bridgeServicePort && bridgeServicePort === "io-bridge") {
+        const servicePort = port.port;
+        if (servicePort !== void 0) {
+          return servicePort;
+        }
+      }
+    }
+    if (item.ports.length === 1) {
+      const port = item.ports[0];
+      const servicePort = port.port;
+      if (servicePort !== void 0) {
+        return servicePort;
+      }
+    }
+  }
+};
+
+// src/kubernetes/KubernetesClient.ts
+var EndpointAddress = class {
+  targetRefName;
+  address;
+  constructor(address, targetRefName) {
+    this.address = address;
+    this.targetRefName = targetRefName;
+  }
+  get ip() {
+    return this.address.ip;
+  }
+  get port() {
+    return this.address.port;
+  }
+};
+var Endpoint = class {
+  privateAddress;
+  publicAddress = void 0;
+  ready;
+  additionalProperties = /* @__PURE__ */ new Map();
+  constructor(privateAddress, publicAddress = void 0, ready, additionalProperties = /* @__PURE__ */ new Map()) {
+    this.privateAddress = privateAddress;
+    this.publicAddress = publicAddress;
+    this.ready = ready;
+    this.additionalProperties = additionalProperties;
+  }
+};
+var READ_TIMEOUT_SECONDS = 10;
+function isReady(podItemStatus) {
+  for (const containerStatus of podItemStatus.containerStatuses) {
+    if (containerStatus.ready !== true) {
+      return false;
+    }
+  }
+  return true;
+}
+function containerPort(container) {
+  const ports = container.ports;
+  if (ports.length > 0) {
+    const port = ports[0];
+    return port.containerPort;
+  }
+}
+function extractContainerPort(item) {
+  const containers = item.spec.containers;
+  if (containers.length === 1) {
+    const container = containers[0];
+    return containerPort(container);
+  } else {
+    for (const container of containers) {
+      if (container.name === "io-bridge") {
+        return containerPort(container);
+      }
+    }
+  }
+}
+function parsePodsList(podList) {
+  const addresses = new Array();
+  for (const item of podList.items) {
+    const podName = item.metadata.name;
+    const status = item.status;
+    const ip = status.podIP;
+    if (ip) {
+      const port = extractContainerPort(item);
+      addresses.push(new Endpoint(new EndpointAddress({ ip, port }, podName), void 0, isReady(status)));
+    }
+  }
+  return addresses;
+}
+function getLabelSelectorParameter(labelNames, labelValues) {
+  const labelNameArray = labelNames.split(",");
+  const labelValueArray = labelValues.split(",");
+  const selectorList = [];
+  for (let i = 0; i < labelNameArray.length; i++) {
+    selectorList[i] = `${labelNameArray[i]}=${labelValueArray[i]}`;
+  }
+  return `labelSelector=${selectorList.join(",")}`;
+}
+var KubernetesClient = class {
+  namespace;
+  kubernetesMaster;
+  exposeExternallyMode;
+  tokenProvider;
+  servicePerPodLabelName;
+  servicePerPodLabelValue;
+  clientTopologyIntentTracker;
+  apiProvider;
+  /*testing*/
+  constructor(namespace, kubernetesMaster, exposeExternallyMode, tokenProvider, servicePerPodLabelName, servicePerPodLabelValue, clientTopologyIntentTracker, apiProvider) {
+    this.namespace = namespace;
+    this.kubernetesMaster = kubernetesMaster;
+    this.exposeExternallyMode = exposeExternallyMode;
+    this.tokenProvider = tokenProvider;
+    this.servicePerPodLabelName = servicePerPodLabelName;
+    this.servicePerPodLabelValue = servicePerPodLabelValue;
+    if (clientTopologyIntentTracker) {
+      clientTopologyIntentTracker.init();
+    }
+    this.apiProvider = apiProvider ?? new KubernetesApiEndpointSlicesProvider();
+  }
+  start() {
+  }
+  destroy() {
+    if (this.clientTopologyIntentTracker) {
+      this.clientTopologyIntentTracker.destroy();
+    }
+  }
+  /**
+   * Returns POD addresses in the specified namespace.
+   *
+   */
+  async endpoints() {
+    try {
+      const url = `${this.kubernetesMaster}/api/v1/namespaces/${this.namespace}/pods`;
+      return this.enrichWithPublicAddresses(parsePodsList(await this.callGet(url)));
+    } catch (e) {
+      return this.handleUnknownError(e);
+    }
+  }
+  /**
+   * Retrieves POD addresses for all services in the specified namespace filtered by service labels and values.
+   * @param serviceLabels      comma separated list of service labels
+   * @param serviceLabelValues comma separated list of service label values
+   * @return all POD addresses from the specified namespace filtered by labels
+   */
+  async endpointsByServiceLabel(serviceLabels, serviceLabelValues) {
+    try {
+      const param = getLabelSelectorParameter(serviceLabels, serviceLabelValues);
+      const url = this.apiProvider.getEndpointsByServiceLabelUrlString(this.kubernetesMaster, this.namespace, param);
+      return this.enrichWithPublicAddresses(this.apiProvider.parseEndpoints(this.callGet(url)));
+    } catch (e) {
+      return this.handleUnknownError(e);
+    }
+  }
+  /**
+   * Retrieves POD addresses from the specified namespace and given endpointName.
+   * @param endpointName endpoint name
+   * @return all POD addresses from the specified namespace and the given endpointName
+   */
+  async endpointsByName(endpointName) {
+    try {
+      const url = this.apiProvider.getEndpointsByNameUrlString(this.kubernetesMaster, this.namespace, endpointName);
+      return this.enrichWithPublicAddresses(this.apiProvider.parseEndpoints(await this.callGet(url)));
+    } catch (e) {
+      return this.handleUnknownError(e);
+    }
+  }
+  /**
+   * Retrieves POD addresses for all services in the specified namespace filtered by pod labels and values.
+   * @param podLabels      comma separated list of pod labels
+   * @param podLabelValues comma separated list of pod label values
+   * @return all POD addresses from the specified namespace filtered by the labels
+   */
+  async endpointsByPodLabel(podLabels, podLabelValues) {
+    try {
+      const param = getLabelSelectorParameter(podLabels, podLabelValues);
+      const url = `${this.kubernetesMaster}/api/v1/namespaces/${this.namespace}/pods?${param}`;
+      return this.enrichWithPublicAddresses(parsePodsList(await this.callGet(url)));
+    } catch (e) {
+      return this.handleUnknownError(e);
+    }
+  }
+  enrichWithPublicAddresses(endpoints) {
+    if (this.exposeExternallyMode === "disabled") {
+      return endpoints;
+    }
+  }
+  handleUnknownError(e) {
+    return [];
+  }
+  async callGet(url) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => {
+      controller.abort(`request to ${url} timed out`);
+    }, READ_TIMEOUT_SECONDS * 1e3);
+    try {
+      const response = await fetch(url, {
+        signal: controller.signal,
+        headers: [["Authorization", `Bearer ${this.tokenProvider()}`]]
+      }).catch((err) => {
+        throw err;
+      });
+      return await response.json();
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+};
+
+// src/kubernetes/KubernetesEndpointResolver.ts
+var DNS_RETRY = 5;
+var KubernetesEndpointResolver = class {
+  logger;
+  constructor(logger) {
+    this.logger = logger;
+  }
+  async start() {
+  }
+  async close() {
+  }
+  async mapAddress(address) {
+    if (!address) {
+      return;
+    }
+    try {
+      let retry = 0;
+      try {
+        return await getByName(address);
+      } catch (e) {
+        if (retry < DNS_RETRY) {
+          retry++;
+        } else {
+          throw e;
+        }
+      }
+    } catch (e) {
+    }
+  }
+};
+
+// src/config/NamedDiscoveryConfig.ts
+var NamedDiscoveryConfig = class {
+  tag;
+  _enabled = false;
+  constructor(tag) {
+    this.tag = tag;
+  }
+  setEnabled(enabled) {
+    this._enabled = enabled;
+    return this;
+  }
+  get enabled() {
+    return this._enabled;
+  }
+};
+
+// src/config/KubernetesConfig.ts
+var KubernetesConfig2 = class extends NamedDiscoveryConfig {
+  constructor() {
+    super("kubernetes");
+  }
+};
+
+// src/config/Config.ts
+var AutoDetectionConfig = class {
+  enabled = true;
+};
+var DefaultMulticastConfig = class {
+  enabled = false;
+  group = "239.1.2.3";
+  port = 34567;
+};
+var DefaultTcpIpConfig = class {
+  enabled = false;
+  members = [];
+};
+var JoinConfig = class {
+  _multicast = new DefaultMulticastConfig();
+  _tcpIp = new DefaultTcpIpConfig();
+  _kubernetes = new KubernetesConfig2();
+  _discovery = new DefaultDiscoveryConfig();
+  _autoDetection = new AutoDetectionConfig();
+  get discovery() {
+    return this._discovery;
+  }
+  get multicast() {
+    return this._multicast;
+  }
+  get autoDetectionEnabled() {
+    return this._autoDetection.enabled && !this._multicast.enabled && !this._tcpIp.enabled && !this._kubernetes.enabled && !this._discovery.enabled;
+  }
+};
+var NetworkConfig = class _NetworkConfig {
+  static DEFAULT_PORT = 8383;
+  port = _NetworkConfig.DEFAULT_PORT;
+  reuseAddress;
+  publicAddress;
+  join = new JoinConfig();
+  constructor() {
+    this.reuseAddress = process.platform !== "win32";
+  }
+};
+var CorsConfig = class {
+  #allowOrigin = void 0;
+  set allowOrigin(value) {
+    if (value !== void 0) {
+      if (value === "*") {
+        this.#allowOrigin = value;
+      } else if (Array.isArray(value)) {
+        this.#allowOrigin = value;
+      } else {
+        this.#allowOrigin = value.split(",");
+      }
+    }
+  }
+  get allowOrigin() {
+    return this.#allowOrigin;
+  }
+  allowCredentials = false;
+};
+var ServerConfig = class {
+  port = void 0;
+  host = void 0;
+  cors = new CorsConfig();
+  auth = {
+    type: "none",
+    basic: {
+      realm: "io.Bridge"
+    }
+  };
+  wsPingInterval = 3e4;
+  // 30 seconds
+};
+var MeshConfig = class {
+  timeout;
+};
+var GatewayConfig = class {
+  enabled;
+  contexts = { lifetime: "retained" };
+};
+var Config = class {
+  properties = {};
+  network = new NetworkConfig();
+  license;
+  server;
+  mesh;
+  gateway;
+  constructor() {
+    this.server = new ServerConfig();
+    this.mesh = new MeshConfig();
+    this.gateway = new GatewayConfig();
+  }
+  get(name) {
+    const value = this.properties[name];
+    return value;
+  }
+  set(name, value) {
+    this.properties[name] = value;
+    return this;
+  }
+};
+
+// src/discovery/SimpleDiscoveryNode.ts
+var SimpleDiscoveryNode = class {
+  privateAddress;
+  publicAddress;
+  properties;
+  constructor(privateAddress, publicAddress, properties) {
+    this.privateAddress = privateAddress;
+    this.publicAddress = publicAddress ?? privateAddress;
+    this.properties = properties ?? /* @__PURE__ */ new Map();
+  }
+};
+
+// src/kubernetes/KubernetesApiEndpointResolver.ts
+function buildKubernetesClient(config, clusterTopologyIntentTracker) {
+  return new KubernetesClient(config.namespace, config.kubernetesMasterUrl, config.exposeExternallyMode, config.tokenProvider, config.servicePerPodLabelName, config.servicePerPodLabelValue, clusterTopologyIntentTracker);
+}
+var KubernetesApiEndpointResolver = class _KubernetesApiEndpointResolver extends KubernetesEndpointResolver {
+  client;
+  serviceName;
+  port = 0;
+  serviceLabel;
+  serviceLabelValue;
+  podLabel;
+  podLabelValue;
+  resolveNotReadyAddresses;
+  static of(logger, config, tracker) {
+    return new _KubernetesApiEndpointResolver(
+      logger,
+      buildKubernetesClient(config, tracker),
+      config.serviceName,
+      config.servicePort,
+      config.serviceLabelName,
+      config.serviceLabelValue,
+      config.podLabelName,
+      config.podLabelValue,
+      config.resolveNotReadyAddresses
+    );
+  }
+  /*testing*/
+  constructor(logger, client, serviceName, port = 0, serviceLabel, serviceLabelValue, podLabel, podLabelValue, resolveNotReadyAddresses) {
+    super(logger);
+    this.client = client;
+    this.serviceName = serviceName;
+    this.port = port;
+    this.serviceLabel = serviceLabel;
+    this.serviceLabelValue = serviceLabelValue;
+    this.podLabel = podLabel;
+    this.podLabelValue = podLabelValue;
+    this.resolveNotReadyAddresses = resolveNotReadyAddresses;
+  }
+  async resolve() {
+    if (this.serviceName) {
+      return await this.getSimpleDiscoveryNodes(await this.client.endpointsByName(this.serviceName));
+    } else if (this.serviceLabel) {
+      return await this.getSimpleDiscoveryNodes(await this.client.endpointsByServiceLabel(this.serviceLabel, this.serviceLabelValue));
+    } else if (this.podLabel) {
+      return await this.getSimpleDiscoveryNodes(await this.client.endpointsByPodLabel(this.podLabel, this.podLabelValue));
+    }
+    return await this.getSimpleDiscoveryNodes(await this.client.endpoints());
+  }
+  async getSimpleDiscoveryNodes(endpoints) {
+    const discoveredNodes = new Array();
+    for (const endpoint of endpoints) {
+      await this.addAddress(discoveredNodes, endpoint);
+    }
+    return discoveredNodes;
+  }
+  async addAddress(discoveredNodes, endpoint) {
+    if (this.resolveNotReadyAddresses === true || endpoint.ready) {
+      const privateAddress = await this.createAddress(endpoint.privateAddress, this.resolvePort.bind(this));
+      const publicAddress = await this.createAddress(endpoint.publicAddress, this.resolvePortPublic.bind(this));
+      discoveredNodes.push(new SimpleDiscoveryNode(privateAddress, publicAddress, /* @__PURE__ */ new Map()));
+    }
+  }
+  async createAddress(address, portResolver) {
+    if (address === void 0) {
+      return void 0;
+    }
+    const ip = address.ip;
+    const ipAddress = await this.mapAddress(ip);
+    const port = portResolver(address);
+    return fromIpAddress(ipAddress, port);
+  }
+  resolvePort(address) {
+    if (this.port > 0) {
+      return this.port;
+    }
+    if (address.port) {
+      return address.port;
+    }
+    return NetworkConfig.DEFAULT_PORT;
+  }
+  resolvePortPublic(address) {
+    if (address.port) {
+      return address.port;
+    }
+    if (this.port > 0) {
+      return this.port;
+    }
+    return NetworkConfig.DEFAULT_PORT;
+  }
+};
+
+// src/kubernetes/KubernetesDiscoveryStrategy.ts
+var KubernetesDiscoveryStrategy = class {
+  logger;
+  endpointResolver;
+  constructor(logger, properties, intentTracker) {
+    this.logger = logger;
+    const config = new KubernetesConfig(properties);
+    this.logger.info(`${config}`);
+    this.endpointResolver = KubernetesApiEndpointResolver.of(this.logger, config, intentTracker);
+    this.logger.info(`Kubernetes Discovery activated with mode: ${config.mode}`);
+  }
+  async start() {
+    await this.endpointResolver.start();
+  }
+  async discover() {
+    return void 0;
+  }
+  async close() {
+    await this.endpointResolver.close();
+  }
+};
+
+// src/kubernetes/KubernetesDiscoveryStrategyFactory.ts
+var PROPERTY_DEFINITIONS = [
+  SERVICE_DNS,
+  SERVICE_NAME,
+  SERVICE_LABEL_NAME,
+  SERVICE_LABEL_VALUE,
+  NAMESPACE,
+  POD_LABEL_NAME,
+  POD_LABEL_VALUE,
+  RESOLVE_NOT_READY_ADDRESSES,
+  EXPOSE_EXTERNALLY,
+  KUBERNETES_MASTER_URL,
+  KUBERNETES_API_TOKEN,
+  SERVICE_PORT
+];
+var KubernetesDiscoveryStrategyFactory = class {
+  tokenPath;
+  priority = DiscoveryStrategyPriorities.PLATFORM;
+  constructor(tokenPath = "/var/run/secrets/kubernetes.io/serviceaccount/token") {
+    this.tokenPath = tokenPath;
+  }
+  async defaultKubernetesMasterReachable() {
+    try {
+      await lookup2("kubernetes.default.svc");
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  async tokenFileExists() {
+    try {
+      await stat(this.tokenPath);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  async isAutoDetectionApplicable() {
+    return await this.tokenFileExists() && await this.defaultKubernetesMasterReachable();
+  }
+  newDiscoveryStrategy(node, logger, properties) {
+    const tracker = node?.properties.get("internal.discovery.cluster.topology.intent.tracker");
+    return new KubernetesDiscoveryStrategy(logger, properties, tracker);
+  }
+  getConfigurationProperties() {
+    return PROPERTY_DEFINITIONS;
+  }
+};
+
+// src/discovery/multicast/MulticastDiscoveryStrategy.ts
+import { createSocket } from "node:dgram";
+
+// src/discovery/multicast/MulticastProperties.ts
+var PORT = property("port", NUMBER);
+var GROUP = property("group", STRING);
+
+// src/discovery/multicast/MulticastDiscoveryStrategy.ts
+var DATA_OUTPUT_BUFFER_SIZE = 64 * 1024;
+var DEFAULT_MULTICAST_PORT = 34567;
+var DEFAULT_MULTICAST_GROUP = "239.1.2.3";
+var SOCKET_TIME_TO_LIVE = 255;
+function multicastDiscoverySender(discoveryNode, socket, group, port) {
+  let multicastMemberInfo;
+  if (discoveryNode) {
+    const address = discoveryNode.publicAddress;
+    multicastMemberInfo = { host: address.host, port: address.port };
+  }
+  const msg = Buffer.from(JSON.stringify(multicastMemberInfo));
+  return () => {
+    socket.send(msg, port, group, (error) => {
+      console.error(error);
+    });
+  };
+}
+function multicastDiscoveryReceiver(socket) {
+  return () => {
+    return new Promise((resolve, reject) => {
+      socket.on("message", (message, remote) => {
+        resolve(JSON.parse(message));
+      });
+      socket.on("error", (err) => {
+        reject(err);
+      });
+    });
+  };
+}
+var MulticastDiscoveryStrategy = class {
+  logger;
+  properties;
+  discoveryNode;
+  isClient;
+  discoverySender;
+  discoveryReceiver;
+  sendIntervalId;
+  socket;
+  constructor(discoveryNode, logger, properties) {
+    this.logger = logger;
+    this.properties = properties;
+    this.discoveryNode = discoveryNode;
+  }
+  async initializeMulticastSocket() {
+    const port = getOrDefault(this.properties, "", PORT, DEFAULT_MULTICAST_PORT);
+    if (port < 0 || port > 65535) {
+      throw new Error("port number must be between 0 and 65535");
+    }
+    const group = getOrDefault(this.properties, "", GROUP, DEFAULT_MULTICAST_GROUP);
+    this.socket = createSocket({
+      type: "udp4",
+      reuseAddr: true,
+      recvBufferSize: DATA_OUTPUT_BUFFER_SIZE,
+      sendBufferSize: DATA_OUTPUT_BUFFER_SIZE
+    });
+    if (this.discoveryNode) {
+      const address = await toIpAddress(this.discoveryNode.privateAddress);
+      if (!isLoopback(address)) {
+        this.socket.setMulticastInterface(address.address);
+      }
+    }
+    this.socket.bind(port, () => {
+      this.socket.setMulticastTTL(SOCKET_TIME_TO_LIVE);
+      this.socket.addMembership(group);
+    });
+    this.discoverySender = multicastDiscoverySender(this.discoveryNode, this.socket, group, port);
+    this.discoveryReceiver = multicastDiscoveryReceiver(this.socket);
+    if (this.discoveryNode == null) {
+      this.isClient = true;
+    }
+  }
+  async discover() {
+    const multicastMemberInfo = await this.discoveryReceiver();
+    if (multicastMemberInfo) {
+      const list = [];
+      try {
+        const discoveryNode = new SimpleDiscoveryNode(await fromHostname(multicastMemberInfo.host, multicastMemberInfo.port));
+        list.push(discoveryNode);
+      } catch (e) {
+        this.logger.trace(e.message);
+      }
+      return list;
+    }
+  }
+  async start() {
+    await this.initializeMulticastSocket();
+    if (!this.isClient) {
+      this.sendIntervalId = setInterval(() => {
+        this.discoverySender();
+      }, 2e3);
+    }
+  }
+  async close() {
+    if (this.sendIntervalId) {
+      clearInterval(this.sendIntervalId);
+      delete this.sendIntervalId;
+    }
+    return new Promise((resolve, reject) => {
+      if (this.socket) {
+        this.socket.close(() => {
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+};
+
+// src/discovery/multicast/MulticastDiscoveryStrategyFactory.ts
+var PROPERTY_DEFINITIONS2 = [
+  GROUP,
+  PORT
+];
+var MulticastDiscoveryStrategyFactory = class {
+  priority = DiscoveryStrategyPriorities.UNKNOWN;
+  newDiscoveryStrategy(discoveryNode, logger, prop) {
+    return new MulticastDiscoveryStrategy(discoveryNode, logger, prop);
+  }
+  async isAutoDetectionApplicable() {
+    return false;
+  }
+  getConfigurationProperties() {
+    return PROPERTY_DEFINITIONS2;
+  }
+};
+
+// src/discovery/index.ts
+var DefaultDiscoveryServiceFactory = class {
+  newDiscoveryService(settings) {
+    return new DefaultDiscoveryService(settings);
+  }
+};
+function verifyNoUnknownProperties(mappedProperties, allProperties) {
+  const unknownProperties = Object.keys(allProperties).filter((key) => !mappedProperties.hasOwnProperty(key));
+  if (unknownProperties.length > 0) {
+    throw new Error(`Unknown properties: ${unknownProperties.join(", ")} on discovery strategy`);
+  }
+}
+function prepareProperties(properties, propertyDefinitions) {
+  const mappedProperties = {};
+  for (const propertyDefinition of propertyDefinitions) {
+    const propertyKey = propertyDefinition.key;
+    if (properties[propertyKey] == void 0) {
+      if (!propertyDefinition.optional) {
+        throw new Error(`Missing required property: ${propertyKey} on discovery strategy`);
+      }
+      continue;
+    }
+    const value = properties[propertyKey];
+    const converter = propertyDefinition.converter;
+    const mappedValue = converter.convert(value);
+    mappedProperties[propertyKey] = mappedValue;
+  }
+  verifyNoUnknownProperties(mappedProperties, properties);
+  return mappedProperties;
+}
+var DefaultDiscoveryService = class {
+  settings;
+  strategies = [];
+  constructor(settings) {
+    this.settings = settings;
+  }
+  async start() {
+    this.strategies.push(...await this.loadDiscoveryStrategies());
+    for (const strategy of this.strategies) {
+      await strategy.start();
+    }
+  }
+  async discover() {
+    const discoveryNodes = /* @__PURE__ */ new Set();
+    for (const strategy of this.strategies) {
+      const candidates = await strategy.discover();
+      if (candidates) {
+        for (const candidate of candidates) {
+          if (this.validateCandidate(candidate)) {
+            discoveryNodes.add(candidate);
+          }
+        }
+      }
+    }
+    return discoveryNodes;
+  }
+  async close() {
+    for (const strategy of this.strategies) {
+      await strategy.close();
+    }
+  }
+  validateCandidate(candidate) {
+    return true;
+  }
+  async loadDiscoveryStrategies() {
+    const discoveryStrategyConfigs = this.settings.conf.discoveryStrategyConfigs;
+    const factories = this.collectFactories(discoveryStrategyConfigs);
+    const discoveryStrategies = new Array();
+    for (const config of discoveryStrategyConfigs) {
+      const discoveryStrategy = await this.buildDiscoveryStrategy(config, factories);
+      discoveryStrategies.push(discoveryStrategy);
+    }
+    const logger = this.settings.logger;
+    if (discoveryStrategies.length == 0 && this.settings.auto) {
+      logger.debug(`Discovery auto-detection enabled, trying to detect discovery strategy`);
+      const autoDetectedFactory = await this.detectDiscoveryStrategyFactory(factories);
+      if (autoDetectedFactory) {
+        logger.debug(`Auto-detected discovery strategy: ${autoDetectedFactory.constructor.name}`);
+        discoveryStrategies.push(autoDetectedFactory.newDiscoveryStrategy(await this.settings.node, logger, {}));
+      } else {
+        logger.debug(`No discovery strategy auto-detected`);
+      }
+    }
+    return discoveryStrategies;
+  }
+  collectFactories(strategyConfigs) {
+    const knownFactories = [new MulticastDiscoveryStrategyFactory(), new KubernetesDiscoveryStrategyFactory()];
+    const factories = new Array();
+    for (const factory of knownFactories) {
+      factories.push(factory);
+    }
+    for (const config of strategyConfigs) {
+      const factory = config.discoveryStrategyFactory;
+      if (factory) {
+        factories.push(factory);
+      }
+    }
+    return factories;
+  }
+  async buildDiscoveryStrategy(config, factories) {
+    const discoveryNode = await this.settings.node;
+    const logger = this.settings.logger;
+    for (const factory of factories) {
+      if (factory.constructor.name == config.discoveryStrategyFactory.constructor.name) {
+        const properties = prepareProperties(config.properties, factory.getConfigurationProperties());
+        return factory.newDiscoveryStrategy(discoveryNode, logger, properties);
+      }
+    }
+    throw new Error("DiscoveryStrategyFactory not found");
+  }
+  async detectDiscoveryStrategyFactory(factories) {
+    let highestPriorityFactory;
+    for (const factory of factories) {
+      try {
+        if (await factory.isAutoDetectionApplicable()) {
+          if (highestPriorityFactory === void 0 || factory.priority > highestPriorityFactory.priority) {
+            highestPriorityFactory = factory;
+          }
+        }
+      } catch (error) {
+      }
+    }
+    return highestPriorityFactory;
+  }
+};
+var DiscoveryStrategyPriorities = {
+  UNKNOWN: 0,
+  PLATFORM: 20,
+  CUSTOM: 50
+};
+
+// src/version/MemberVersion.ts
+function parse(version) {
+  const pattern = /(\d+)\.(\d+)(\.(\d+))?(-\w+(?:-\d+)?)?$/g;
+  const x = pattern.exec(version);
+  const major = parseInt(x[1]);
+  const minor = parseInt(x[2]);
+  const patch = x[3] ? parseInt(x[4]) : 0;
+  return [major, minor, patch];
+}
+var MemberVersion = class {
+  major;
+  minor;
+  patch;
+  get isUnknown() {
+    return this.major === 0 && this.minor === 0 && this.patch === 0;
+  }
+  toString() {
+    return `${this.major}.${this.minor}.${this.patch}`;
+  }
+  constructor(major, minor, patch) {
+    this.major = major;
+    this.minor = minor;
+    this.patch = patch;
+  }
+};
+var UNKNOWN_VERSION = new MemberVersion(0, 0, 0);
+function parseVersion(version) {
+  if (!version || version.startsWith("0.0.0")) {
+    return UNKNOWN_VERSION;
+  }
+  return new MemberVersion(...parse(version));
+}
+
+// package.json
+var package_default = {
+  name: "@interopio/bridge",
+  version: "0.0.3-beta",
+  license: "see license in license.md",
+  author: "interop.io",
+  homepage: "https://docs.interop.io/bridge",
+  keywords: [
+    "io.bridge",
+    "bridge",
+    "io.connect",
+    "glue42",
+    "interop.io"
+  ],
+  type: "module",
+  exports: {
+    "./package.json": "./package.json",
+    ".": {
+      import: "./dist/index.js"
+    }
+  },
+  bin: {
+    bridge: "./bin/bridge.js"
+  },
+  scripts: {
+    test: "mocha test --recursive",
+    "build:types": "tsc --declaration --emitDeclarationOnly --outDir types",
+    build: "esbuild src/main.mts --outdir=dist --bundle --packages=external --sourcemap --platform=node --format=esm --target=es2024"
+  },
+  dependencies: {
+    "@interopio/gateway-server": "^0.7.0-beta",
+    dotenv: "^17.2.1",
+    jsrsasign: "^11.1.0",
+    nanoid: "^5.0.9"
+  },
+  devDependencies: {
+    "@types/jsrsasign": "^10.5.15",
+    "@types/ws": "^8.18.1",
+    "rand-seed": "^3.0.0"
+  },
+  engines: {
+    node: ">= 20.15 || >=22.2.0 || >=24.0"
+  }
+};
+
+// src/instance/AddressPicker.ts
+import { createServer } from "node:net";
+async function createAddress(addressDef, port) {
+  if (addressDef.host) {
+    return { type: addressDef.ipAddress.family, host: addressDef.host, port, address: addressDef.ipAddress };
+  }
+  return { type: addressDef.ipAddress.family, host: await addressDef.ipAddress.getHost(), port, address: addressDef.ipAddress };
+}
+function createNetServer(logger, host, range) {
+  const ports = portRange(range);
+  return new Promise((resolve, reject) => {
+    let server = createServer({}, () => {
+    });
+    server.on("error", (err) => {
+      if (err["code"] === "EADDRINUSE") {
+        logger.debug(`port ${err["port"]} already in use on address ${err["address"]}`);
+        const { value: port } = ports.next();
+        if (port) {
+          logger.info(`retry starting server on port ${port} and host ${host ?? "<unspecified>"}`);
+          server.close();
+          server.listen(port, host);
+        } else {
+          logger.warn(`all configured port(s) ${range} are in use. closing...`);
+          server.close();
+          reject(err);
+        }
+      } else {
+        logger.error(`server error: ${err.message}`, err);
+        reject(err);
+      }
+    });
+    server.on("listening", () => {
+      const info = server.address();
+      logger.info(`listening on ${info.address}:${info.port}`);
+      resolve(server);
+    });
+    try {
+      const { value: port } = ports.next();
+      server.listen(port, host);
+    } catch (e) {
+      logger.error(`error starting socket server`, e);
+      reject(e instanceof Error ? e : new Error(`listen failed: ${e}`));
+    }
+  });
+}
+var InterfaceAddress = class {
+  address;
+  host;
+  constructor(address, host) {
+    this.address = address;
+    this.host = host;
+  }
+};
+var AddressDef = class extends InterfaceAddress {
+  ipAddress;
+  port;
+  constructor(ipAddress, host, port) {
+    super(ipAddress.address, host);
+    this.ipAddress = ipAddress;
+    this.port = port ?? 0;
+  }
+};
+var DefaultAddressPicker = class {
+  #logger;
+  #config;
+  #publicAddressConfig;
+  #publicAddress;
+  #bindAddress;
+  server;
+  #port;
+  constructor(config, logger) {
+    this.#logger = logger;
+    this.#config = config;
+    this.#port = config.network.port;
+    this.#publicAddressConfig = config.network.publicAddress;
+  }
+  async pickAddress() {
+    if (this.#publicAddress || this.#bindAddress) {
+      return;
+    }
+    const publicAddressDef = await this.getPublicAddressByPortSearch();
+    this.#publicAddress = this.#bindAddress;
+  }
+  getPublicAddressFor(endpoint) {
+    return this.#publicAddress;
+  }
+  getServers() {
+    return /* @__PURE__ */ new Map([["member", this.server]]);
+  }
+  async getPublicAddressByPortSearch() {
+    const bindAddressDef = await this.pickAddressDef();
+    this.server = await createNetServer(this.#logger, "0.0.0.0", bindAddressDef.port === 0 ? this.#port : bindAddressDef.port);
+    const port = this.server.address().port;
+    this.#bindAddress = await createAddress(bindAddressDef, port);
+    return this.getPublicAddress(port);
+  }
+  async getPublicAddress(port) {
+    let address = this.#publicAddressConfig;
+    if (address) {
+      address = address.trim();
+      if (!address) {
+        throw new Error("Public address is empty");
+      } else if ("127.0.0.1" === address) {
+        return this.pickLoopbackAddressDef(address, port);
+      } else {
+        const ipAddress = await getByName(address);
+        return new AddressDef(ipAddress, address, port);
+      }
+    }
+  }
+  async pickAddressDef() {
+    let addressDef = this.pickInterfaceAddressDef();
+    if (addressDef) {
+    }
+    if (addressDef === void 0) {
+      addressDef = await this.pickLoopbackAddressDef();
+    }
+    return addressDef;
+  }
+  pickInterfaceAddressDef() {
+    const interfaces = this.getInterfaces();
+    if (interfaces) {
+      const address = this.pickMatchingAddress(interfaces);
+      if (address) {
+        return address;
+      }
+    }
+    return this.pickMatchingAddress();
+  }
+  getInterfaces() {
+    return [];
+  }
+  async pickLoopbackAddressDef(host, defaultPort) {
+    const address = await getByName("127.0.0.1");
+    return new AddressDef(address, host, defaultPort);
+  }
+  match(ipAddress, interfaces) {
+    for (const iface of interfaces) {
+      if (ipAddress.address === iface.address) {
+        return iface;
+      }
+    }
+    return void 0;
+  }
+  getMatchingAddress(ipAddress, interfaces) {
+    if (interfaces) {
+      return this.match(ipAddress, interfaces);
+    } else {
+      return ipAddress;
+    }
+  }
+  pickMatchingAddress(interfaces) {
+    const preferIPv4 = true;
+    const networkInterfaces2 = getNetworkInterfaces();
+    let matchingAddress;
+    for (const ni of networkInterfaces2) {
+      if (!interfaces && ni.loopback) {
+        continue;
+      }
+      for (const ipAddress of ni.addresses) {
+        if (preferIPv4 && ipAddress.family === 6) {
+          continue;
+        }
+        const address = this.getMatchingAddress(ipAddress, interfaces);
+        break;
+      }
+    }
+    return matchingAddress;
+  }
+};
+var PORT_RANGE_MATCHER = /^(\d+|(0x[\da-f]+))(-(\d+|(0x[\da-f]+)))?$/i;
+function validPort(port) {
+  if (port > 65535) throw new Error(`bad port ${port}`);
+  return port;
+}
+function* portRange(port) {
+  if (typeof port === "string") {
+    for (const portRange2 of port.split(",")) {
+      const trimmed = portRange2.trim();
+      const matchResult = PORT_RANGE_MATCHER.exec(trimmed);
+      if (matchResult) {
+        const start = parseInt(matchResult[1]);
+        const end = parseInt(matchResult[4] ?? matchResult[1]);
+        for (let i = validPort(start); i < validPort(end) + 1; i++) {
+          yield i;
+        }
+      } else {
+        throw new Error(`'${portRange2}' is not a valid port or range.`);
+      }
+    }
+  } else {
+    yield validPort(port);
+  }
+}
+
+// src/instance/BridgeNode.ts
+import gatewayServer from "@interopio/gateway-server";
+
+// src/license/types.ts
+var licenseValidationResults = {
+  TRIAL_LICENSE_EXPIRED: { licenseType: "trial", expired: true, fatal: true },
+  TRIAL_LICENSE_VALID: { licenseType: "trial", expired: false, fatal: false },
+  PAID_LICENSE_EXPIRED: { licenseType: "paid", expired: true, fatal: false },
+  PAID_LICENSE_VALID: { licenseType: "paid", expired: false, fatal: false },
+  NO_LICENSE: { licenseType: "none", expired: false, fatal: true }
+};
+
+// src/license/LicenseValidator.ts
+import { KJUR } from "jsrsasign";
+var LicenseError = class extends Error {
+  licensePayload;
+  constructor(message, licensePayload) {
+    super(message);
+    this.licensePayload = licensePayload;
+  }
+};
+var LicenseEvaluator = class {
+  tokenResultMap = {
+    "trial-false": licenseValidationResults.TRIAL_LICENSE_VALID,
+    "trial-true": licenseValidationResults.TRIAL_LICENSE_EXPIRED,
+    "paid-false": licenseValidationResults.PAID_LICENSE_VALID,
+    "paid-true": licenseValidationResults.PAID_LICENSE_EXPIRED
+  };
+  validationKey;
+  constructor(validationKey2) {
+    if (!validationKey2 || typeof validationKey2 !== "string") {
+      throw new Error(`Validation key must be a non-empty string`);
+    }
+    this.validationKey = validationKey2;
+  }
+  decrypt(token) {
+    if (KJUR.jws.JWS.verifyJWT(token, this.validationKey, { alg: ["RS256"] })) {
+      return KJUR.jws.JWS.parse(token).payloadObj;
+    } else {
+      throw new LicenseError("invalid jwt token", token);
+    }
+  }
+  validateBasicTokenData(token) {
+    const decoded = this.decrypt(token);
+    if (["paid", "trial"].indexOf(decoded.type) === -1) {
+      throw new LicenseError("Invalid license type", token);
+    }
+    return decoded;
+  }
+  getLicenseStatus(token, now = /* @__PURE__ */ new Date()) {
+    try {
+      const license = this.validateBasicTokenData(token);
+      const isExpired = license.expiration < now.getTime();
+      const licenseValidationResult = this.tokenResultMap[`${license.type}-${isExpired}`];
+      return {
+        ...licenseValidationResult,
+        license
+      };
+    } catch (e) {
+      return {
+        ...licenseValidationResults.NO_LICENSE,
+        error: e.message
+      };
+    }
+  }
+};
+var LicenseValidator = class {
+  licenseHelper;
+  logger;
+  constructor({ validationKey: validationKey2, logger }) {
+    this.licenseHelper = new LicenseEvaluator(validationKey2);
+    this.logger = logger ?? getLogger("LicenseValidator");
+  }
+  validate(licenseKeyString, options) {
+    if (typeof licenseKeyString !== "string") {
+      throw new LicenseError("Invalid license key format", licenseKeyString);
+    }
+    const licenseStatus = this.licenseHelper.getLicenseStatus(licenseKeyString);
+    this.printLicenseMessage(licenseStatus, options?.logSuccessMessages ?? true);
+    if (licenseStatus.fatal) {
+      throw new LicenseError("License validation failed", licenseStatus.license);
+    }
+  }
+  printLicenseMessage(licenseStatus, logSuccessMessages) {
+    if (!licenseStatus || licenseStatus.licenseType === "none") {
+      this.logger.error("This license is invalid. Please contact us at sales@interop.io to get a valid license");
+      return;
+    }
+    const message = [
+      licenseStatus.licenseType === "paid" ? `This is a paid license that was issued for client ` : `This is a trial license that was issued for `,
+      licenseStatus.license.organization.displayName,
+      licenseStatus.expired ? `, but it has expired at ` : ` and is valid until `,
+      new Date(licenseStatus.license.expiration).toString(),
+      "."
+    ].join("");
+    if (licenseStatus.fatal) {
+      this.logger.error(message);
+    } else if (licenseStatus.expired) {
+      this.logger.warn(message);
+    } else if (logSuccessMessages) {
+      this.logger.info(message);
+    }
+  }
+};
+
+// src/license/BridgeLicenseValidator.ts
+var validationKey = `-----BEGIN PUBLIC KEY-----
+MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAyyZrtwcQCMfyOkZDcjxZ
++07BrvgcAvoQETF+ho8VLfaDxgNPZd6Q7jZEfrtv0+wn0pxx8pUDeBh8mCYvkwmb
+9tkFH47GJuDhWasNgyp4ugRX4bzoPV3SnHsBR4KJ/F76kBbike6sdIfO2lYGZ36s
+LJPHV7epOYsfhoc4343/vOxEPvNbwacbXWl4NsCGev4qUmWhe9iMpb/JPd3o4hIU
+SR31AmR2xoh3BkAJc2q/cSeQK6Kn9nZYocyW367+7FOvYsrOYotsuUASp0OWp+Lh
+WGfR7F6d016+u6kbvLvcceGztiP1u25QmPNCUmw49cTatthiEwwGHb01CR58mStZ
+xg5t9+N7X9hPO2K59b8EbOnnFTlwtMMF7MKR56S4YwMamCChr9WGgpOQV+lrqyx2
+yn9lwn8Yf4gLoLPKBEhHTEy6r/we9qymmlSSe4wr5Fctov2odSE535nvtdRYZkKk
+t32gOXuwnKg2kRlRSAErpyou1mz7/mWEt1H3sGTRArjNTP2KqZkc14vPToEEJt93
+ZKjhD1pVEchDiWBOMj9o12pq80tGZ8PhGJasJVVi0JPUiaznG4r12JdyDAjuXMru
+6f4Tx0ULkdwn9ia7lchcq7xC2PlTnYz+fGpfU7V0Ci56QDTp6oP567L1EIeddkaI
+nIsi4KHT7Ctp047FTTelntUCAwEAAQ==
+-----END PUBLIC KEY-----`;
+var BridgeLicenseValidator = (logger) => new LicenseValidator({ validationKey, logger });
+
+// src/instance/BridgeNode.ts
+import { userInfo } from "node:os";
+
+// ../bridge-mesh/src/mesh/connections.ts
+import "@interopio/gateway";
+var InMemoryNodeConnections = class {
+  #logger;
+  #nodes = /* @__PURE__ */ new Map();
+  #nodesByEndpoint = /* @__PURE__ */ new Map();
+  #memberIds = 0;
+  #timeout;
+  constructor(logger, timeout = 6e4) {
+    this.#logger = logger;
+    this.#timeout = timeout;
+  }
+  announce(nodes) {
+    for (const node of nodes) {
+      const { node: nodeId, users, endpoint } = node;
+      const foundId = this.#nodesByEndpoint.get(endpoint);
+      if (foundId) {
+        if (foundId !== nodeId) {
+          this.#logger.warn(`endpoint ${endpoint} clash. replacing node ${foundId} with ${nodeId}`);
+          this.#nodesByEndpoint.set(endpoint, nodeId);
+          this.#nodes.delete(foundId);
+        }
+      } else {
+        this.#logger.info(`endpoint ${endpoint} announced for ${nodeId}`);
+        this.#nodesByEndpoint.set(endpoint, nodeId);
+      }
+      this.#nodes.set(nodeId, this.updateNode(node, new Set(users ?? []), nodeId, this.#nodes.get(nodeId)));
+    }
+    this.cleanupOldNodes();
+    const sortedNodes = this.sortedNodeValues();
+    return nodes.map((e) => {
+      const { node } = e;
+      const connect = this.findConnections(sortedNodes, this.#nodes.get(node));
+      return { node, connect };
+    });
+  }
+  find(nodeId) {
+    const e = this.#nodes.get(nodeId);
+    if (e !== void 0) {
+      const sortedNodes = this.sortedNodeValues();
+      const { node } = e;
+      return this.findConnections(sortedNodes, this.#nodes.get(node));
+    }
+    return void 0;
+  }
+  remove(nodeId) {
+    const removed = this.#nodes.get(nodeId);
+    if (removed !== void 0) {
+      this.#nodes.delete(nodeId);
+      const endpoint = removed.endpoint;
+      this.#nodesByEndpoint.delete(endpoint);
+      this.#logger.info(`endpoint ${endpoint} removed for ${nodeId}`);
+      return true;
+    }
+    return false;
+  }
+  updateNode(newNode, users, _key, oldNode) {
+    const node = oldNode ?? { ...newNode, memberId: this.#memberIds++ };
+    return { ...node, users, lastAccess: Date.now() };
+  }
+  sortedNodeValues() {
+    return Array.from(this.#nodes.values()).sort((a, b) => a.memberId - b.memberId);
+  }
+  cleanupOldNodes() {
+    const threshold = Date.now() - this.#timeout;
+    for (const [nodeId, v] of this.#nodes) {
+      if (v.lastAccess < threshold) {
+        if (this.#logger.enabledFor("debug")) {
+          this.#logger.debug(`${nodeId} expired - no announcement since ${new Date(v.lastAccess).toISOString()}, timeout is ${this.#timeout} ms.`);
+        }
+        this.#nodes.delete(nodeId);
+      }
+    }
+  }
+  findConnections(sortedNodes, node) {
+    return sortedNodes.reduce((l, c) => {
+      if (node !== void 0 && c.memberId < node.memberId) {
+        const intersection = new Set(c.users);
+        node.users.forEach((user) => {
+          if (!c.users.has(user)) {
+            intersection.delete(user);
+          }
+        });
+        c.users.forEach((user) => {
+          if (!node.users.has(user)) {
+            intersection.delete(user);
+          }
+        });
+        if (intersection.size > 0) {
+          const e = { node: c.node, endpoint: c.endpoint };
+          return l.concat(e);
+        }
+      }
+      return l;
+    }, new Array());
+  }
+};
+
+// ../bridge-mesh/src/mesh/relays.ts
+import { IOGateway as IOGateway3 } from "@interopio/gateway";
+var codec = IOGateway3.Encoding.transit({
+  keywordize: /* @__PURE__ */ new Map([
+    ["/type", "*"],
+    ["/message/body/type", "*"],
+    ["/message/origin", "*"],
+    ["/message/receiver/type", "*"],
+    ["/message/source/type", "*"],
+    ["/message/body/type", "*"]
+  ])
+});
+var InternalRelays = class {
+  #logger;
+  // key -> socket
+  #clients = /* @__PURE__ */ new Map();
+  // node -> key
+  #links = /* @__PURE__ */ new Map();
+  onMsg;
+  onErr;
+  constructor(logger) {
+    this.#logger = logger;
+  }
+  add(key, soc) {
+    this.#clients.set(key, soc);
+  }
+  remove(key) {
+    this.#clients.delete(key);
+    for (const [node, k] of this.#links) {
+      if (k === key) {
+        this.#links.delete(node);
+      }
+    }
+  }
+  receive(key, msg) {
+    const node = this.link(key, msg);
+    if (node && this.onMsg) {
+      this.onMsg(key, node, msg);
+    }
+  }
+  link(key, msg) {
+    try {
+      const decoded = codec.decode(msg);
+      const { type, from, to } = decoded;
+      if (to === "all") {
+        switch (type) {
+          case "hello": {
+            if (this.#logger.enabledFor("debug")) {
+              this.#logger.debug(`${key} registers node ${from}`);
+            }
+            this.#links.set(from, key);
+            break;
+          }
+          case "bye": {
+            if (this.#logger.enabledFor("debug")) {
+              this.#logger.debug(`${key} unregisters node ${from}`);
+            }
+            this.#links.delete(from);
+            break;
+          }
+        }
+        return;
+      }
+      return from;
+    } catch (e) {
+      if (this.onErr) {
+        this.onErr(key, e instanceof Error ? e : new Error(`link failed :${e}`));
+      } else {
+        this.#logger.warn(`${key} unable to process ${msg}`, e);
+      }
+    }
+  }
+  send(key, node, msg, cb) {
+    const decoded = codec.decode(msg);
+    if (this.#logger.enabledFor("debug")) {
+      this.#logger.debug(`${key} sending msg to ${node} ${JSON.stringify(decoded)}`);
+    }
+    const clientKey = this.#links.get(node);
+    if (clientKey) {
+      const client = this.#clients.get(clientKey);
+      if (client) {
+        client.send(msg, { binary: false }, (err) => {
+          cb(clientKey, err);
+        });
+        return;
+      }
+    }
+    throw new Error(`${key} no active link for ${decoded.to}`);
+  }
+};
+
+// ../bridge-mesh/src/mesh/rest-directory/routes.ts
+function routes(config, { handle }) {
+  const { connections, authorize } = config;
+  handle(
+    {
+      request: { method: "POST", path: "/api/nodes" },
+      options: { cors: true, authorize },
+      handler: async ({ request, response }) => {
+        const json = await request.json;
+        if (!Array.isArray(json)) {
+          response.statusCode = 400;
+          await response.end();
+        } else {
+          const nodes = json;
+          const result = connections.announce(nodes);
+          const buffer = Buffer.from(JSON.stringify(result), "utf-8");
+          response.statusCode = 200;
+          response.headers.set("Content-Type", "application/json; charset=utf-8").set("Content-Length", buffer.length);
+          await response.end(buffer);
+        }
+      }
+    },
+    {
+      request: { method: "GET", path: /^\/api\/nodes\/(?<nodeId>.*)$/ },
+      options: { cors: true, authorize },
+      handler: async ({ request, response }, { nodeId }) => {
+        const result = connections.find(nodeId);
+        if (result === void 0) {
+          const buffer = Buffer.from(JSON.stringify(result), "utf-8");
+          response.statusCode = 200;
+          response.headers.set("Content-Type", "application/json; charset=utf-8").set("Content-Length", buffer.length);
+          await response.end(buffer);
+        } else {
+          response.statusCode = 404;
+          await response.end();
+        }
+      }
+    },
+    {
+      request: { method: "DELETE", path: /^\/api\/nodes\/(?<nodeId>.*)$/ },
+      options: { cors: true, authorize },
+      handler: async ({ response }, { nodeId }) => {
+        const removed = connections.remove(nodeId);
+        if (removed) {
+          response.statusCode = 200;
+        } else {
+          response.statusCode = 404;
+        }
+        await response.end();
+      }
+    }
+  );
+}
+var routes_default = routes;
+
+// ../bridge-mesh/src/mesh/ws/relays/core.ts
+import "@interopio/gateway";
+async function create(log, internal, env) {
+  log.info(`relays server is listening`);
+  return async (socket, handshake) => {
+    const key = handshake.logPrefix;
+    log.info(`${key} connected on relays`);
+    internal.add(key, socket);
+    socket.on("error", (err) => {
+      log.error(`[${key}] websocket error: ${err}`, err);
+    });
+    socket.on("message", (data, _isBinary) => {
+      if (Array.isArray(data)) {
+        data = Buffer.concat(data);
+      }
+      try {
+        internal.receive(key, data);
+      } catch (e) {
+        log.warn(`[${key}] error processing received data '${data}'`, e);
+      }
+    });
+    socket.on("close", (code, reason) => {
+      internal.remove(key);
+      log.info(`${key} disconnected from relays`);
+    });
+  };
+}
+var meshRelays = ({ logger, internal }) => {
+  return async (env) => {
+    return await create(logger, internal, env);
+  };
+};
+
+// ../bridge-mesh/src/mesh/ws/cluster/core.ts
+import "@interopio/gateway";
+function onMessage(relays, log, key, node, socketsByNodeId, msg) {
+  try {
+    relays.send(key, node, msg, (k, err) => {
+      if (err) {
+        log.warn(`${k} error writing msg ${msg}: ${err}`);
+        return;
+      }
+      if (log.enabledFor("debug")) {
+        log.debug(`${k} sent msg ${msg}`);
+      }
+    });
+  } catch (ex) {
+    log.error(`${key} unable to process message`, ex);
+    if (node) {
+      const socket = socketsByNodeId.get(node)?.get(key);
+      socket?.terminate();
+    }
+  }
+}
+async function create2(log, relays, _env) {
+  const socketsByNodeId = /* @__PURE__ */ new Map();
+  relays.onMsg = (k, nodeId, msg) => {
+    try {
+      const sockets = socketsByNodeId.get(nodeId);
+      if (sockets && sockets.size > 0) {
+        for (const [key, socket] of sockets) {
+          socket.send(msg, { binary: false }, (err) => {
+            if (err) {
+              log.warn(`${key} error writing from ${k} msg ${msg}: ${err}`);
+              return;
+            }
+            if (log.enabledFor("debug")) {
+              log.debug(`${key} sent from ${k} msg ${msg}`);
+            }
+          });
+        }
+      } else {
+        log.warn(`${k} dropped msg ${msg}.`);
+      }
+    } catch (ex) {
+      log.error(`${k} unable to process message`, ex);
+    }
+  };
+  return async (socket, handshake) => {
+    const key = handshake.logPrefix;
+    const query = handshake.url.searchParams;
+    log.info(`${key} connected on cluster with ${query}`);
+    const node = query.get("node");
+    if (node) {
+      let sockets = socketsByNodeId.get(node);
+      if (!sockets) {
+        sockets = /* @__PURE__ */ new Map();
+        socketsByNodeId.set(node, sockets);
+      }
+      sockets.set(key, socket);
+    } else {
+      socket.terminate();
+      return;
+    }
+    socket.on("error", (err) => {
+      log.error(`${key} websocket error: ${err}`, err);
+    });
+    socket.on("message", (data, _isBinary) => {
+      if (Array.isArray(data)) {
+        data = Buffer.concat(data);
+      }
+      onMessage(relays, log, key, node, socketsByNodeId, data);
+    });
+    socket.on("close", (_code, _reason) => {
+      log.info(`${key} disconnected from cluster`);
+      const sockets = socketsByNodeId.get(node);
+      if (sockets) {
+        sockets.delete(key);
+        if (sockets.size === 0) {
+          socketsByNodeId.delete(node);
+        }
+      }
+    });
+  };
+}
+var meshCluster = ({ logger, relays }) => {
+  return async (environment) => {
+    return await create2(logger, relays, environment);
+  };
+};
+
+// ../bridge-mesh/src/index.ts
+import "@interopio/gateway-server";
+import "@interopio/gateway";
+var mesh = async (options, configurer, config) => {
+  const { enabled, logger } = options;
+  if (enabled !== true) {
+    logger.debug(`no mesh`);
+    return;
+  }
+  let { socket, timeout } = options;
+  const authorize = socket.authorize ?? { access: config.auth.type === "none" ? "permitted" : "authenticated" };
+  socket = { ping: 3e4, authorize, ...socket };
+  timeout ??= 6e4;
+  const connections = new InMemoryNodeConnections(logger, timeout);
+  const relays = new InternalRelays(logger);
+  routes_default({ connections, authorize }, configurer);
+  configurer.socket(
+    {
+      path: "/cluster",
+      options: socket,
+      factory: meshCluster({ logger, relays })
+    },
+    {
+      path: "/relays",
+      options: socket,
+      factory: meshRelays({ logger, internal: relays })
+    }
+  );
+};
+
+// src/instance/BridgeNode.ts
+function logStartingInfo(logger) {
+  logger.info(`Starting io.Bridge v${package_default.version} using Node.js ${process.version} with PID ${process.pid} (started by ${userInfo().username} in ${process.cwd()})`);
+}
+function createDiscoveryService(logger, conf, isAutoDetectionEnabled, localMember) {
+  const factory = new DefaultDiscoveryServiceFactory();
+  const node = localMember.then((member) => new SimpleDiscoveryNode(member.address));
+  const settings = {
+    mode: "member",
+    node,
+    conf,
+    auto: isAutoDetectionEnabled,
+    logger
+  };
+  return factory.newDiscoveryService(settings);
+}
+function createAddressPicker(node) {
+  const config = node.config;
+  const logger = node.getLogger("AddressPicker");
+  return new DefaultAddressPicker(config, logger);
+}
+var BridgeNode = class {
+  config;
+  uuid;
+  discoveryService;
+  version;
+  server;
+  licenseValidator;
+  constructor(config) {
+    this.config = config;
+    this.licenseValidator = BridgeLicenseValidator(this.getLogger("license-validator"));
+    this.licenseValidator.validate(config.license);
+    this.uuid = newUUID();
+    this.version = parseVersion(package_default.version);
+    const addressPicker = createAddressPicker(this);
+    const localMemberPromise = addressPicker.pickAddress().then(() => addressPicker.getPublicAddressFor("member")).then((publicAddress) => {
+      return {
+        local: true,
+        address: publicAddress,
+        uuid: this.uuid,
+        version: this.version
+      };
+    });
+    const joinConfig = config.network.join;
+    const isAutoDetectionEnabled = joinConfig.autoDetectionEnabled;
+    const discoveryConfig = joinConfig.discovery;
+    this.discoveryService = createDiscoveryService(getLogger("discovery-service"), discoveryConfig, isAutoDetectionEnabled, localMemberPromise);
+  }
+  getLogger(name) {
+    return getLogger(name);
+  }
+  async scheduleLicenseCheck() {
+    const task = async () => {
+      try {
+        this.licenseValidator.validate(this.config.license, {
+          logSuccessMessages: false
+        });
+      } catch (error) {
+        await this.stop();
+      }
+    };
+    const licenseCheckInterval = 1e3 * 60 * 60 * 24;
+    return setInterval(task, licenseCheckInterval);
+  }
+  async start() {
+    const config = {
+      port: this.config.server.port,
+      host: this.config.server.host,
+      app: async (configurer, config2) => {
+        await mesh({
+          logger: this.getLogger("mesh"),
+          enabled: true,
+          timeout: this.config.mesh.timeout ?? 6e4,
+          // 60 seconds
+          socket: {
+            ping: this.config.server.wsPingInterval ?? 3e4
+            // 30 seconds
+          }
+        }, configurer, config2);
+      },
+      auth: { type: "none", ...this.config.server.auth },
+      cors: this.config.server.cors
+    };
+    if (this.config.gateway.enabled) {
+      config.gateway = {
+        clients: {
+          inactive_seconds: 0
+        },
+        ping: this.config.server.wsPingInterval ?? void 0,
+        mesh: {
+          cluster: {
+            endpoint: `http://localhost:${this.config.server.port}`,
+            directory: { interval: 1e3 * 30 }
+            // 30 seconds
+          }
+        },
+        contexts: {
+          lifetime: this.config.gateway.contexts.lifetime,
+          visibility: [{ restrictions: "cluster" }]
+        },
+        peers: {
+          visibility: [{
+            domain: "interop",
+            restrictions: "local"
+          }]
+        }
+      };
+    }
+    logStartingInfo(this.getLogger("node"));
+    this.server = await gatewayServer(config);
+    if (false) {
+      await this.discoveryService.start();
+    }
+    await this.scheduleLicenseCheck();
+  }
+  async stop() {
+    if (this.server) {
+      await this.server.close();
+    }
+    try {
+      await this.discoveryService.close();
+    } catch (e) {
+    }
+  }
+};
+
+// src/main.mts
+var hadFatalError = false;
+var reportedErrors = /* @__PURE__ */ new Set();
+function onFatalError(error) {
+  process.exitCode = 2;
+  hadFatalError = true;
+  const errorMessage = `io.Bridge: ${package_default.version}`;
+  if (!reportedErrors.has(errorMessage)) {
+    console.error(error);
+    reportedErrors.add(errorMessage);
+  }
+}
+function propertyNameToEnvKey(name) {
+  return `IO_BRIDGE_${name.toUpperCase().replaceAll("-", "").replaceAll(".", "_")}`;
+}
+function loadConfig(name, converter) {
+  const cmdArg = process.argv.find((arg) => {
+    return arg.startsWith(`--${name}=`);
+  })?.split("=")[1];
+  if (cmdArg) {
+    return converter.convert(cmdArg);
+  }
+  const envKey = propertyNameToEnvKey(name);
+  const envVar = process.env[envKey];
+  if (envVar) {
+    return converter.convert(envVar);
+  }
+}
+try {
+  process.on("uncaughtException", onFatalError);
+  process.on("unhandledRejection", onFatalError);
+  await import("dotenv/config");
+  const config = new Config();
+  config.license ??= loadConfig("license.key", STRING);
+  config.server.port ??= loadConfig("server.port", NUMBER) ?? 8383;
+  config.server.host ??= loadConfig("server.host", STRING);
+  config.server.wsPingInterval ??= loadConfig("server.ws-ping-interval", NUMBER);
+  config.gateway.enabled ??= loadConfig("gateway.enabled", BOOLEAN);
+  config.gateway.contexts.lifetime ??= loadConfig("gateway.contexts.lifetime", STRING);
+  config.server.auth.type = loadConfig("server.auth.type", STRING) ?? "none";
+  config.server.cors.allowOrigin = loadConfig("server.cors.allow-origin", STRING) ?? "*";
+  config.server.cors.allowCredentials = loadConfig("server.cors.allow-credentials", BOOLEAN) ?? true;
+  const bridge = new BridgeNode(config);
+  await bridge.start();
+} catch (error) {
+  onFatalError(error);
+}
+//# sourceMappingURL=main.js.map