@interopio/bridge 0.0.6-beta.0 → 0.1.0-beta.0

package/dist/main.js

@@ -1,3 +1,125 @@
+// ../bridge-mesh/src/mesh/relays.ts
+import { IOGateway } from "@interopio/gateway";
+import { EventEmitter } from "node:events";
+var codec = IOGateway.Encoding.transit({
+  keywordize: /* @__PURE__ */ new Map([
+    ["/type", "*"],
+    ["/message/body/type", "*"],
+    ["/message/origin", "*"],
+    ["/message/receiver/type", "*"],
+    ["/message/source/type", "*"],
+    ["/message/body/type", "*"]
+  ])
+});
+function isEncoded(msg) {
+  return typeof msg === "string" || Buffer.isBuffer(msg);
+}
+var InternalRelays = class {
+  #logger;
+  // key -> handler
+  #handlersByKey = /* @__PURE__ */ new Map();
+  // node -> keyed link
+  #links = /* @__PURE__ */ new Map();
+  #eventEmitter = new EventEmitter();
+  constructor(logger) {
+    this.#logger = logger;
+  }
+  add(key, handler) {
+    this.#handlersByKey.set(key, handler);
+  }
+  remove(key) {
+    this.#handlersByKey.delete(key);
+    this.#disconnect(key);
+  }
+  #disconnect(key, from) {
+    for (const [node, k] of this.#links) {
+      if (k.key === key && (from === void 0 || k.node === from)) {
+        const links = k.linksByNode;
+        if (this.#logger.enabledFor("debug")) {
+          this.#logger.debug(`${key} unregisters node ${node}, linked to ${Array.from(links.keys()).join(", ")}`);
+        }
+        this.#links.delete(node);
+        this.#eventEmitter.emit("disconnect", key, node, links);
+      }
+    }
+  }
+  #connect(key, node) {
+    if (this.#logger.enabledFor("debug")) {
+      this.#logger.debug(`${key} registers node ${node}`);
+    }
+    this.#links.set(node, { key, node, linksByNode: /* @__PURE__ */ new Map() });
+    this.#eventEmitter.emit("connect", key, node);
+  }
+  receive(key, msg) {
+    const { node, decoded, encoded } = this.link(key, msg);
+    if (node) {
+      this.#eventEmitter.emit("message", key, node, encoded, decoded);
+    }
+  }
+  link(key, msg) {
+    try {
+      const decoded = isEncoded(msg) ? codec.decode(msg) : msg;
+      const { type, from, to } = decoded;
+      if (to === "all") {
+        switch (type) {
+          case "hello": {
+            this.#connect(key, from);
+            break;
+          }
+          case "bye": {
+            this.#disconnect(key, from);
+            break;
+          }
+        }
+        return { decoded };
+      }
+      const encoded = isEncoded(msg) ? msg : codec.encode(msg);
+      return { node: from, decoded, encoded };
+    } catch (e) {
+      if (!this.#eventEmitter.emit("error", key, e instanceof Error ? e : new Error(`link failed :${e}`))) {
+        this.#logger.warn(`${key} unable to process ${msg}`, e);
+      }
+    }
+  }
+  on(event, listener) {
+    this.#eventEmitter.on(event, listener);
+    return this;
+  }
+  send(key, node, msg, cb) {
+    if (this.#logger.enabledFor("debug")) {
+      this.#logger.debug(`${key} sending msg to ${node}`);
+    }
+    const encoded = isEncoded(msg) ? msg : codec.encode(msg);
+    const decoded = isEncoded(msg) ? codec.decode(msg) : msg;
+    {
+      const senderLinkData = this.#links.get(decoded.from);
+      switch (decoded.type) {
+        case "hello":
+          if (node === decoded.to) {
+            senderLinkData?.linksByNode.set(decoded.to, key);
+          }
+          break;
+        case "bye":
+          if (node === decoded.to) {
+            senderLinkData?.linksByNode.delete(decoded.to);
+          }
+          break;
+      }
+    }
+    {
+      const receiverLinkData = this.#links.get(node);
+      if (receiverLinkData?.key) {
+        const handler = this.#handlersByKey.get(receiverLinkData?.key);
+        if (handler) {
+          handler(encoded, decoded, cb);
+          return;
+        }
+      }
+    }
+    throw new Error(`${key} no active link for ${node}`);
+  }
+};
+
 // src/utils/uuid.ts
 import { nanoid } from "nanoid";
 function newUUID() {
@@ -201,9 +323,9 @@ var DefaultDiscoveryConfig = class {
 };
 
 // src/logging.ts
-import { IOGateway } from "@interopio/gateway";
+import { getLogger as getGatewayLogger } from "@interopio/gateway/logging/core";
 function getLogger(name) {
-  return IOGateway.Logging.getLogger(`gateway.bridge.${name}`);
+  return getGatewayLogger(`gateway.bridge.${name}`);
 }
 
 // src/kubernetes/KubernetesDiscoveryStrategyFactory.ts
@@ -697,6 +819,9 @@ var ServerConfig = class {
     type: "none",
     basic: {
       realm: "io.Bridge"
+    },
+    oauth2: {
+      jwt: { issuerUri: "" }
     }
   };
   wsPingInterval = 3e4;
@@ -1209,7 +1334,7 @@ function parseVersion(version) {
 // package.json
 var package_default = {
   name: "@interopio/bridge",
-  version: "0.0.6-beta.0",
+  version: "0.1.0-beta.0",
   license: "see license in license.md",
   author: "interop.io",
   homepage: "https://docs.interop.io/bridge",
@@ -1220,6 +1345,11 @@ var package_default = {
     "glue42",
     "interop.io"
   ],
+  repository: {
+    type: "git",
+    url: "https://github.com/InteropIO/bridge.git",
+    directory: "packages/bridge"
+  },
   type: "module",
   exports: {
     "./package.json": "./package.json",
@@ -1244,12 +1374,13 @@ var package_default = {
     build: "npm run build:main && npm run build:index"
   },
   dependencies: {
-    "@interopio/gateway-server": "^0.10.0-beta.0",
-    dotenv: "^17.2.2",
+    "@interopio/gateway-server": "^0.13.0-beta.1",
+    dotenv: "^17.2.3",
     jsrsasign: "^11.1.0",
-    nanoid: "^5.0.9"
+    nanoid: "^5.1.6"
   },
   devDependencies: {
+    "@interopio/gateway": "^0.16.1-beta.0",
     "@types/jsrsasign": "^10.5.15",
     "@types/ws": "^8.18.1",
     "rand-seed": "^3.0.0"
@@ -1579,195 +1710,6 @@ var BridgeLicenseValidator = (logger) => new LicenseValidator({ validationKey, l
 // 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 buildCanonicalBaseURL(request) {
   const requestURL = request.URL;
@@ -1888,7 +1830,11 @@ async function create(log, internal, env) {
     const logPrefix = handshake.logPrefix;
     const key = `r.${id}.${++keyId}`;
     log.info(`${logPrefix}connected on /relays with assigned key ${key}`);
-    internal.add(key, socket);
+    internal.add(key, (msg, c, cb) => {
+      socket.send(msg, { binary: false }, (err) => {
+        cb(key, err);
+      });
+    });
     socket.on("error", (err) => {
       log.error(`${logPrefix}websocket error: ${err.message}`, err);
     });
@@ -1908,9 +1854,9 @@ async function create(log, internal, env) {
     });
   };
 }
-var meshRelays = ({ logger, internal }) => {
+var meshRelays = ({ logger, relays }) => {
   return async (env) => {
-    return await create(logger, internal, env);
+    return await create(logger, relays, env);
   };
 };
 
@@ -1938,10 +1884,13 @@ function onMessage(relays, log, key, node, socketsByNodeId, msg) {
 var handlerId2 = 0;
 async function create2(log, relays, env) {
   const socketsByNodeId = /* @__PURE__ */ new Map();
-  relays.onMsg = (k, nodeId, msg) => {
+  relays.on("message", (k, nodeId, msg) => {
     try {
       const sockets = socketsByNodeId.get(nodeId);
       if (sockets && sockets.size > 0) {
+        if (log.enabledFor("trace")) {
+          log.debug(`${k} sending message to ${[...sockets.keys()]}`);
+        }
         for (const [key, socket] of sockets) {
           socket.send(msg, { binary: false }, (err) => {
             if (err) {
@@ -1959,7 +1908,16 @@ async function create2(log, relays, env) {
     } catch (ex) {
       log.error(`${k} unable to process message`, ex);
     }
-  };
+  });
+  relays.on("disconnect", (k, nodeId) => {
+    const sockets = socketsByNodeId.get(nodeId);
+    if (sockets) {
+      for (const [key, socket] of sockets) {
+        socket.terminate();
+        log.info(`${key} terminated because ${k} disconnected ${nodeId}`);
+      }
+    }
+  });
   const id = ++handlerId2;
   let keyId = 0;
   return async ({ socket, handshake }) => {
@@ -2008,19 +1966,222 @@ var meshCluster = ({ logger, relays }) => {
 
 // ../bridge-mesh/src/index.ts
 import "@interopio/gateway-server";
-import "@interopio/gateway";
+
+// ../bridge-mesh/src/mesh/gateway/mesh.ts
+import { nanoid as nanoid2 } from "nanoid";
+var instanceId = 0;
+var BridgeMeshChannel = class {
+  #logger;
+  #relays;
+  #connections;
+  #state;
+  #keyPrefix;
+  constructor(relays, nodes, logger) {
+    this.#relays = relays;
+    this.#connections = nodes;
+    this.#logger = logger;
+    this.#state = /* @__PURE__ */ new Map();
+    this.#keyPrefix = `g.${++instanceId}`;
+  }
+  get relays() {
+    return this.#relays;
+  }
+  get connections() {
+    return this.#connections;
+  }
+  #intervalId;
+  subscribe(node, subscriber) {
+    node ??= nanoid2();
+    const key = `${this.#keyPrefix}-${node}`;
+    if (this.#state.has(key)) {
+      throw new Error(`already subscribed to node ${node}`);
+    }
+    this.#state.set(node, { subscriber, users: /* @__PURE__ */ new Set(), members: /* @__PURE__ */ new Set() });
+    this.#relays.receive(key, { type: "hello", from: node, to: "all" });
+    this.#relays.add(key, this.createRelayClient(key, node));
+    this.#intervalId ??= setInterval(() => this.#announce(), 3e4);
+    return node;
+  }
+  createRelayClient(key, node) {
+    return (_msg, command, cb) => {
+      switch (command.type) {
+        case "hello":
+        case "bye":
+          break;
+        case "data": {
+          try {
+            const event = {
+              type: "message-received",
+              message: command.data
+            };
+            this.#state.get(node)?.subscriber(event, node, this);
+          } catch (err) {
+            cb(key, err);
+          }
+          break;
+        }
+      }
+    };
+  }
+  unsubscribe(node) {
+    this.#delete(node);
+    this.#relays.remove(`${this.#keyPrefix}-${node}`);
+  }
+  execute(node, action) {
+    switch (action.type) {
+      case "publish-message": {
+        this.#onMessage(node, action.message);
+        break;
+      }
+      case "add-users": {
+        this.#onAddUsers(node, action.added);
+        break;
+      }
+      case "remove-users": {
+        this.#onRemoveUsers(node, action.removed);
+        break;
+      }
+    }
+  }
+  #onMessage(node, data) {
+    const nodes = this.#connections.find(node);
+    if (nodes !== void 0) {
+      const key = `${this.#keyPrefix}-${node}`;
+      const command = { type: "data", from: node, data };
+      nodes.forEach((connection) => {
+        const to = connection.node;
+        if (to === node) {
+          return;
+        }
+        try {
+          this.#relays.send(key, to, { ...command, to }, (k, err) => {
+            if (err) {
+              this.#logger.warn(`failed to send message from ${node} to ${to} via ${k}: ${err.message}`);
+            }
+          });
+        } catch (err) {
+          this.#logger.warn(`failed to send message from ${node} to ${to} via ${key}: ${err.message}`);
+        }
+      });
+    }
+  }
+  #onAddUsers(node, usersToAdd) {
+    let shouldAnnounce = false;
+    const nodeState = this.#state.get(node);
+    const nodeUsers = nodeState?.users;
+    if (nodeUsers === void 0) {
+      nodeState.users = new Set(usersToAdd);
+      shouldAnnounce = true;
+    } else {
+      for (const u of usersToAdd) {
+        if (nodeUsers.has(u)) {
+          continue;
+        }
+        nodeUsers.add(u);
+        shouldAnnounce = true;
+      }
+    }
+    if (shouldAnnounce) {
+      this.#announce(node);
+    }
+  }
+  #onRemoveUsers(node, usersToRemove) {
+    const nodeState = this.#state.get(node);
+    const nodeUsers = nodeState?.users;
+    if (nodeUsers === void 0) {
+      return;
+    }
+    let shouldAnnounce = false;
+    for (const u of usersToRemove) {
+      if (!nodeUsers.has(u)) {
+        continue;
+      }
+      nodeUsers.delete(u);
+      shouldAnnounce = true;
+    }
+    if (nodeUsers.size === 0) {
+      this.#delete(node);
+    } else if (shouldAnnounce) {
+      this.#announce(node);
+    }
+  }
+  #announce(node) {
+    const entries = node === void 0 ? this.#state.entries() : [[node, this.#state.get(node)]];
+    const nodes = Array.from(entries, entryToNode);
+    const nodeConnections = this.#connections.announce(nodes);
+    for (const { node: n, connect } of nodeConnections) {
+      const state = this.#state.get(n);
+      if (state === void 0) {
+        continue;
+      }
+      const toRemove = new Set(state.members);
+      for (const c of connect) {
+        if (c.node === n) {
+          continue;
+        }
+        toRemove.delete(c.node);
+        if (state.members.has(c.node)) {
+          continue;
+        }
+        state.members.add(c.node);
+        state.subscriber({ type: "member-added", node: c.node }, n, this);
+      }
+      for (const r of toRemove) {
+        state.members.delete(r);
+        state.subscriber({ type: "member-removed", node: r }, n, this);
+      }
+    }
+  }
+  #delete(node) {
+    this.#state.delete(node);
+    this.#connections.remove(node);
+  }
+  close() {
+    for (const node of this.#state.keys()) {
+      this.#delete(node);
+      this.#relays.remove(`${this.#keyPrefix}-${node}`);
+    }
+    clearInterval(this.#intervalId);
+  }
+};
+var entryToNode = ([node, state]) => {
+  const users = Array.from(state?.users);
+  const endpoint = `/cluster?node=${node}`;
+  return { node, endpoint, users };
+};
+
+// ../bridge-mesh/src/index.ts
+function connectNodeRelays(logger, relays, connections) {
+  relays.on("disconnect", (key, node, links) => {
+    for (const [linkNode, linkKey] of links) {
+      try {
+        relays.send(linkKey, linkNode, { type: "bye", from: node, to: linkNode }, (k, err) => {
+          if (err) {
+            logger.warn(`${k} error writing 'bye' msg to ${linkNode}: ${err}`);
+            return;
+          }
+          if (logger.enabledFor("debug")) {
+            logger.debug(`${k} sent 'bye' msg to ${linkNode}`);
+          }
+        });
+      } catch (err) {
+        logger.warn(`${linkKey} exception writing 'bye' msg to ${linkNode}: ${err}`);
+      }
+    }
+  });
+}
 var mesh = async (options, configurer, config) => {
-  const { enabled, logger } = options;
+  const { enabled, logger, relays, connections } = options;
   if (enabled !== true) {
-    logger.debug(`no mesh`);
+    if (logger.enabledFor("debug")) {
+      logger.debug(`no mesh`);
+    }
     return;
   }
-  let { socket, timeout } = options;
+  let { socket } = 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);
+  connectNodeRelays(logger, relays, connections);
   routes_default({ connections, authorize }, configurer);
   configurer.socket(
     {
@@ -2031,11 +2192,258 @@ var mesh = async (options, configurer, config) => {
     {
       path: "/relays",
       options: socket,
-      factory: meshRelays({ logger, internal: relays })
+      factory: meshRelays({ logger, relays })
     }
   );
 };
 
+// ../bridge-mesh/src/mesh/connections.ts
+import "@interopio/gateway";
+import { EventEmitter as EventEmitter2 } from "node:events";
+var OrderedMap = class {
+  #elements = [];
+  #binarySearch(key) {
+    let low = 0;
+    let high = this.#elements.length - 1;
+    while (low <= high) {
+      const mid = low + high >> 1;
+      const cmp = this.#elements[mid][0].localeCompare(key);
+      if (cmp === 0) return mid;
+      if (cmp < 0) low = mid + 1;
+      else high = mid - 1;
+    }
+    return -low - 1;
+  }
+  set(key, value) {
+    const idx = this.#binarySearch(key);
+    if (idx >= 0) {
+      this.#elements[idx][1] = value;
+    } else {
+      this.#elements.splice(~idx, 0, [key, value]);
+    }
+  }
+  get(key) {
+    const idx = this.#binarySearch(key);
+    return idx >= 0 ? this.#elements[idx][1] : void 0;
+  }
+  has(key) {
+    return this.#binarySearch(key) >= 0;
+  }
+  delete(key) {
+    const idx = this.#binarySearch(key);
+    if (idx >= 0) {
+      this.#elements.splice(idx, 1);
+      return true;
+    }
+    return false;
+  }
+  entries() {
+    return this.#elements[Symbol.iterator]();
+  }
+  values() {
+    return this.#elements.map((e) => e[1]);
+  }
+};
+var InMemoryNodeConnections = class {
+  #logger;
+  #eventEmitter = new EventEmitter2();
+  #nodes = new OrderedMap();
+  #nodesByEndpoint = /* @__PURE__ */ new Map();
+  #timeout;
+  constructor(logger, timeout = 6e4) {
+    this.#logger = logger;
+    this.#timeout = timeout;
+  }
+  announce(nodes) {
+    const now = Date.now();
+    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);
+          this.#eventEmitter.emit("endpoint-deleted", foundId, endpoint, "clashed");
+        }
+      } else {
+        this.#logger.info(`endpoint ${endpoint} announced for ${nodeId}`);
+        this.#nodesByEndpoint.set(endpoint, nodeId);
+      }
+      const set = new Set(users ?? []);
+      this.#nodes.set(nodeId, this.updateNode(node, set, nodeId, now, this.#nodes.get(nodeId)));
+      this.#eventEmitter.emit("endpoint-announced", nodeId, endpoint, set);
+    }
+    this.cleanupOldNodes();
+    return nodes.map((e) => {
+      const { node } = e;
+      const connect = this.findConnections(this.#nodes.get(node));
+      return { node, connect };
+    });
+  }
+  find(nodeId) {
+    const e = this.#nodes.get(nodeId);
+    if (e !== void 0) {
+      return this.findConnections(e);
+    }
+    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}`);
+      this.#eventEmitter.emit("endpoint-deleted", nodeId, endpoint, "removed");
+      return true;
+    }
+    return false;
+  }
+  updateNode(newNode, users, _key, lastAccess, oldNode) {
+    const node = oldNode ?? { ...newNode };
+    return { ...node, users, lastAccess };
+  }
+  cleanupOldNodes() {
+    const threshold = Date.now() - this.#timeout;
+    for (const [nodeId, v] of this.#nodes.entries()) {
+      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);
+        const endpoint = v.endpoint;
+        this.#nodesByEndpoint.delete(endpoint);
+        this.#eventEmitter.emit("endpoint-deleted", nodeId, endpoint, "expired");
+      }
+    }
+  }
+  on(event, listener) {
+    this.#eventEmitter.on(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    this.#eventEmitter.off(event, listener);
+    return this;
+  }
+  findConnections(node) {
+    const connections = new Array();
+    for (const [key, value] of this.#nodes.entries()) {
+      if (node !== void 0 && key < node.node) {
+        const intersection = new Set(value.users);
+        node.users.forEach((user) => {
+          if (!value.users.has(user)) {
+            intersection.delete(user);
+          }
+        });
+        value.users.forEach((user) => {
+          if (!node.users.has(user)) {
+            intersection.delete(user);
+          }
+        });
+        if (intersection.size > 0) {
+          const e = { node: value.node, endpoint: value.endpoint };
+          connections.push(e);
+        }
+      }
+    }
+    return connections;
+  }
+};
+
+// ../bridge-gateway/src/desktop.ts
+function isRunningInConnectDesktop(env = process.env) {
+  return env._GD_STARTING_CONTEXT_ !== void 0;
+}
+function parseStartingContext(env = process.env) {
+  if (!isRunningInConnectDesktop(env)) {
+    throw new Error("Not running in io.Connect Desktop");
+  }
+  return JSON.parse(env._GD_STARTING_CONTEXT_).applicationConfig?.customProperties;
+}
+
+// ../bridge-gateway/src/index.ts
+import { tmpdir } from "node:os";
+import { createServer as createServer2 } from "node:net";
+import { join } from "node:path";
+import "@interopio/gateway";
+import "@interopio/gateway-server";
+function onGatewayStarted(log) {
+  return (gateway) => {
+    const info = JSON.stringify(gateway.info());
+    if (isRunningInConnectDesktop()) {
+      const env = process.env["GLUE-ENV"] || "DEMO";
+      const region = process.env["GLUE-REGION"] || "INTEROP.IO";
+      const user = process.env.USERNAME ?? process.env.USER;
+      const pipe = `glue42-${env}-${region}-${user}`;
+      const pipeName = process.platform === "win32" ? `\\\\.\\pipe\\${pipe}` : `${join(tmpdir(), pipe + ".sock")}`;
+      log.info(`gateway started: ${info}, opening ${pipeName}`);
+      const server = createServer2((stream) => {
+        log.info(`stream connected, sending info...`);
+        stream.write(info);
+        stream.end(() => {
+          server.close();
+        });
+      });
+      server.listen(pipeName);
+    } else {
+      log.info(`gateway started: ${info}`);
+    }
+  };
+}
+async function serverGatewayConfig(gateway, bridge, env = process.env) {
+  let enabled = gateway.enabled;
+  if (enabled === void 0) {
+    if (isRunningInConnectDesktop(env)) {
+      enabled = parseStartingContext(env)?.gatewayApp === true;
+    }
+  }
+  let contextsLifetime = gateway.contexts.lifetime;
+  if (contextsLifetime === void 0) {
+    if (isRunningInConnectDesktop(env)) {
+      contextsLifetime = "retained";
+    }
+  }
+  if (enabled) {
+    return {
+      // globals: { websocket },
+      clients: {
+        inactive_seconds: 0
+      },
+      ping: bridge.wsPingInterval ?? void 0,
+      mesh: {
+        channel: bridge.meshChannel
+      },
+      contexts: {
+        lifetime: contextsLifetime,
+        visibility: [
+          { context: /___channel___.+/, restrictions: "cluster" },
+          { context: /T42\..*/, restrictions: "local" },
+          { context: "___platform_prefs___", restrictions: "local" },
+          { context: /___workspace___.+/, restrictions: "local" },
+          { context: /___window-hibernation___.+/, restrictions: "local" },
+          { context: /___instance___.+/, restrictions: "local" },
+          { context: /___window___.+/, restrictions: "local" },
+          { restrictions: "cluster" }
+        ]
+      },
+      methods: {
+        visibility: [
+          { method: /T42\..*/, restrictions: "local" },
+          { restrictions: "cluster" }
+        ]
+      },
+      peers: {
+        visibility: [
+          { domain: "context", restrictions: "cluster" },
+          { domain: "interop", restrictions: "cluster" },
+          { domain: "bus", restrictions: "local" }
+        ]
+      }
+    };
+  }
+}
+
 // 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()})`);
@@ -2061,12 +2469,13 @@ var BridgeNode = class {
   config;
   uuid;
   discoveryService;
+  meshChannel;
   version;
   server;
   licenseValidator;
   constructor(config) {
     this.config = config;
-    this.licenseValidator = BridgeLicenseValidator(this.getLogger("license-validator"));
+    this.licenseValidator = BridgeLicenseValidator(this.getLogger("license"));
     this.licenseValidator.validate(config.license);
     this.uuid = newUUID();
     this.version = parseVersion(package_default.version);
@@ -2082,7 +2491,10 @@ var BridgeNode = class {
     const joinConfig = config.network.join;
     const isAutoDetectionEnabled = joinConfig.autoDetectionEnabled;
     const discoveryConfig = joinConfig.discovery;
-    this.discoveryService = createDiscoveryService(getLogger("discovery-service"), discoveryConfig, isAutoDetectionEnabled, localMemberPromise);
+    this.discoveryService = createDiscoveryService(getLogger("discovery"), discoveryConfig, isAutoDetectionEnabled, localMemberPromise);
+    const relays = new InternalRelays(this.getLogger("relays"));
+    const connections = new InMemoryNodeConnections(this.getLogger("nodes"), this.config.mesh.timeout ?? 6e4);
+    this.meshChannel = new BridgeMeshChannel(relays, connections, this.getLogger("channel"));
   }
   getLogger(name) {
     return getLogger(name);
@@ -2108,8 +2520,8 @@ var BridgeNode = class {
         await mesh({
           logger: this.getLogger("mesh"),
           enabled: true,
-          timeout: this.config.mesh.timeout ?? 6e4,
-          // 60 seconds
+          relays: this.meshChannel.relays,
+          connections: this.meshChannel.connections,
           socket: {
             ping: this.config.server.wsPingInterval ?? 3e4
             // 30 seconds
@@ -2119,50 +2531,15 @@ var BridgeNode = class {
       auth: { type: "none", ...this.config.server.auth },
       cors: this.config.server.cors.disabled ? false : this.config.server.cors
     };
-    if (this.config.gateway.enabled) {
-      const { WebSocket: websocket } = await import("ws");
-      config.gateway = {
-        globals: { websocket },
-        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: [
-            { context: /___channel___.+/, restrictions: "cluster" },
-            { context: /T42\..*/, restrictions: "local" },
-            { context: "___platform_prefs___", restrictions: "local" },
-            { restrictions: "cluster" }
-          ]
-        },
-        methods: {
-          visibility: [
-            { method: /T42\..*/, restrictions: "local" },
-            { restrictions: "cluster" }
-          ]
-        },
-        peers: {
-          visibility: [
-            { domain: "context", restrictions: "cluster" },
-            { domain: "interop", restrictions: "cluster" },
-            { domain: "bus", restrictions: "local" }
-          ]
-        }
-      };
-    }
+    config.gateway = await serverGatewayConfig(this.config.gateway, { meshChannel: this.meshChannel, wsPingInterval: this.config.server.wsPingInterval });
     logStartingInfo(this.getLogger("node"));
     this.server = await gatewayServer(config);
     if (false) {
       await this.discoveryService.start();
     }
+    if (config.gateway !== void 0) {
+      onGatewayStarted(this.getLogger("gw"))(this.server.gateway);
+    }
     await this.scheduleLicenseCheck();
   }
   async stop() {
@@ -2173,6 +2550,7 @@ var BridgeNode = class {
       await this.discoveryService.close();
     } catch (e) {
     }
+    this.meshChannel.close();
   }
 };
 
@@ -2234,12 +2612,15 @@ try {
   await import("dotenv/config");
   const config = new Config();
   config.license ??= loadLicense();
-  config.server.port ??= loadConfig("server.port", NUMBER) ?? 8383;
+  config.server.port ??= loadConfig("server.port", NUMBER) ?? 8084;
   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.auth.oauth2.jwt.issuerUri = loadConfig("server.auth.oauth2.jwt.issuer-uri", STRING) ?? void 0;
+  config.server.auth.oauth2.jwt.issuer = loadConfig("server.auth.oauth2.jwt.issuer", STRING) ?? void 0;
+  config.server.auth.oauth2.jwt.audience = loadConfig("server.auth.oauth2.jwt.audience", STRING) ?? void 0;
   config.server.cors.allowOrigin = loadConfig("server.cors.allow-origin", STRING) ?? "*";
   config.server.cors.allowCredentials = loadConfig("server.cors.allow-credentials", BOOLEAN) ?? true;
   config.server.cors.disabled = loadConfig("server.cors.disabled", BOOLEAN) ?? false ? true : void 0;