@interopio/bridge 0.0.6-beta.0 → 1.0.0

package/dist/main.js

@@ -1,3 +1,152 @@
+// ../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("info")) {
+          this.#logger.info(`${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("info")) {
+      this.#logger.info(`${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 };
+      } else {
+        const node = decoded.to;
+        const link = decoded.from;
+        const type2 = decoded.type;
+        const senderLinkData = this.#links.get(link);
+        switch (type2) {
+          case "hello":
+            if (this.#logger.enabledFor("debug")) {
+              this.#logger.debug(`${key} connecting ${link} to ${node}`);
+            }
+            senderLinkData?.linksByNode.set(decoded.to, key);
+            break;
+          case "bye":
+            if (this.#logger.enabledFor("debug")) {
+              this.#logger.debug(`${key} disconnecting ${link} from ${node}`);
+            }
+            senderLinkData?.linksByNode.delete(decoded.to);
+            break;
+        }
+      }
+      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("trace")) {
+      this.#logger.debug(`${key} sending msg to ${node}`);
+    }
+    const encoded = isEncoded(msg) ? msg : codec.encode(msg);
+    const decoded = isEncoded(msg) ? codec.decode(msg) : msg;
+    {
+      node ??= decoded.to;
+      const link = decoded.from;
+      const type = decoded.type;
+      const senderLinkData = this.#links.get(link);
+      switch (type) {
+        case "hello":
+          if (this.#logger.enabledFor("debug")) {
+            this.#logger.debug(`${key} connecting ${link} to ${node}`);
+          }
+          senderLinkData?.linksByNode.set(node, key);
+          break;
+        case "bye":
+          if (this.#logger.enabledFor("debug")) {
+            this.#logger.debug(`${key} disconnecting ${link} from ${node}`);
+          }
+          senderLinkData?.linksByNode.delete(node);
+          break;
+      }
+    }
+    {
+      const receiverLinkData = this.#links.get(node);
+      if (receiverLinkData?.key) {
+        const handler = this.#handlersByKey.get(receiverLinkData?.key);
+        if (handler) {
+          handler(encoded, decoded, cb);
+          return;
+        }
+      }
+    }
+    if (decoded.type === "bye") {
+      return;
+    }
+    throw new Error(`${key} no active link for ${node}`);
+  }
+};
+
 // src/utils/uuid.ts
 import { nanoid } from "nanoid";
 function newUUID() {
@@ -201,9 +350,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 +846,9 @@ var ServerConfig = class {
     type: "none",
     basic: {
       realm: "io.Bridge"
+    },
+    oauth2: {
+      jwt: { issuerUri: "" }
     }
   };
   wsPingInterval = 3e4;
@@ -1209,7 +1361,7 @@ function parseVersion(version) {
 // package.json
 var package_default = {
   name: "@interopio/bridge",
-  version: "0.0.6-beta.0",
+  version: "1.0.0",
   license: "see license in license.md",
   author: "interop.io",
   homepage: "https://docs.interop.io/bridge",
@@ -1220,6 +1372,11 @@ var package_default = {
     "glue42",
     "interop.io"
   ],
+  repository: {
+    type: "git",
+    url: "git+https://github.com/InteropIO/bridge.git",
+    directory: "packages/bridge"
+  },
   type: "module",
   exports: {
     "./package.json": "./package.json",
@@ -1234,7 +1391,7 @@ var package_default = {
     }
   },
   bin: {
-    bridge: "./bin/bridge.js"
+    bridge: "bin/bridge.js"
   },
   scripts: {
     test: "mocha test --recursive",
@@ -1244,12 +1401,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.17.0",
+    dotenv: "^17.2.3",
     jsrsasign: "^11.1.0",
-    nanoid: "^5.0.9"
+    nanoid: "^5.1.6"
   },
   devDependencies: {
+    "@interopio/gateway": "^0.20.0",
     "@types/jsrsasign": "^10.5.15",
     "@types/ws": "^8.18.1",
     "rand-seed": "^3.0.0"
@@ -1579,195 +1737,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;
@@ -1817,9 +1786,13 @@ function routes(config, { handle }) {
           );
           await response.end();
         } else {
-          const nodes = json.map((node) => fromRequestNode(node, request));
+          const nodes = json.map((node) => {
+            return fromRequestNode(node, request);
+          });
           const result = connections.announce(nodes).map((connection) => {
-            const connect = connection.connect?.map((node) => toRequestNode(node, request));
+            const connect = connection.connect?.map((node) => {
+              return toRequestNode(node, request);
+            });
             return { ...connection, connect };
           });
           const buffer = Buffer.from(JSON.stringify(result), "utf8");
@@ -1885,10 +1858,15 @@ async function create(log, internal, env) {
   log.info(`relays-${id} server is listening on ${env.endpoint}`);
   let keyId = 0;
   return async ({ socket, handshake }) => {
-    const logPrefix = handshake.logPrefix;
+    const logPrefix = handshake.logPrefix ?? "";
+    const query = handshake.url.searchParams;
     const key = `r.${id}.${++keyId}`;
-    log.info(`${logPrefix}connected on /relays with assigned key ${key}`);
-    internal.add(key, socket);
+    log.info(`${logPrefix}connected on /relays with ${query} and assigned key ${key}`);
+    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 +1886,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);
   };
 };
 
@@ -1923,7 +1901,7 @@ function onMessage(relays, log, key, node, socketsByNodeId, msg) {
         log.warn(`${k} error writing msg ${msg}: ${err}`);
         return;
       }
-      if (log.enabledFor("debug")) {
+      if (log.enabledFor("trace")) {
         log.debug(`${k} sent msg ${msg}`);
       }
     });
@@ -1938,17 +1916,20 @@ 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) {
               log.warn(`${key} error writing from ${k} msg ${msg}: ${err}`);
               return;
             }
-            if (log.enabledFor("debug")) {
+            if (log.enabledFor("trace")) {
               log.debug(`${key} sent from ${k} msg ${msg}`);
             }
           });
@@ -1959,14 +1940,23 @@ 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 }) => {
     const logPrefix = handshake.logPrefix ?? "";
     const query = handshake.url.searchParams;
     const key = `c.${id}.${++keyId}`;
-    log.info(`${logPrefix}connected on /cluster with ${query} with assigned key ${key}`);
+    log.info(`${logPrefix}connected on /cluster with ${query} and assigned key ${key}`);
     const node = query.get("node");
     if (node) {
       let sockets = socketsByNodeId.get(node);
@@ -2008,19 +1998,231 @@ 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";
+import gateway from "@interopio/gateway/package.json" with { type: "json" };
+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);
+  }
+  async init(gossipTimestamp = 0) {
+    await this.#connections.init(gossipTimestamp);
+  }
+  async close() {
+    for (const node of this.#state.keys()) {
+      this.#delete(node);
+      this.#relays.remove(`${this.#keyPrefix}-${node}`);
+    }
+    clearInterval(this.#intervalId);
+    await this.#connections.close();
+  }
+};
+var entryToNode = ([node, state]) => {
+  const users = Array.from(state?.users);
+  return { node, users, metadata: { version: gateway.version, type: "bridge" } };
+};
+
+// ../bridge-mesh/src/index.ts
+function connectNodeRelays(logger, relays, connections) {
+  relays.on("disconnect", (key, node, links) => {
+    try {
+      connections.remove(node);
+    } catch (e) {
+      logger.warn(`${key} error removing node ${node} from connections: ${e}`);
+    }
+    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} from ${node}`);
+          }
+        });
+      } catch (err) {
+        logger.warn(`${linkKey} exception writing 'bye' msg to ${linkNode} from ${node}: ${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 +2233,321 @@ 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 { hrwHash } from "hrw-hash";
+
+// ../bridge-mesh/src/mesh/lamport.ts
+import { appendFile, readFile, rename, writeFile } from "node:fs/promises";
+var LamportClock = class _LamportClock {
+  static #FLUSH_INTERVAL = 5e3;
+  // 5 seconds
+  static #CLOCK_FILE = "./lamport.clock";
+  static #WAL_FILE = "./lamport.wal";
+  #timestamp;
+  #instanceId;
+  #flushIntervalId;
+  #pendingWrites = 0;
+  constructor(instanceId2) {
+    this.#instanceId = instanceId2;
+    this.#timestamp = 0;
+    this.#flushIntervalId = setInterval(() => {
+      this.#flush().catch((err) => {
+      });
+    }, _LamportClock.#FLUSH_INTERVAL);
+  }
+  async init(gossipTimestamp = 0) {
+    const baseTimestamp = await this.#loadSnapshot();
+    const journaledIncrements = await this.#replayWal();
+    this.#timestamp = Math.max(baseTimestamp + journaledIncrements, gossipTimestamp);
+  }
+  tick() {
+    this.#timestamp += 1;
+    this.#pendingWrites += 1;
+    this.#appendToWal().catch((_err) => {
+    });
+    return { timestamp: this.#timestamp, instanceId: this.#instanceId };
+  }
+  observe(gossipTimestamp) {
+    this.#timestamp = Math.max(this.#timestamp, gossipTimestamp) + 1;
+    this.#pendingWrites += 1;
+    this.#appendToWal().catch((_err) => {
+    });
+    return { timestamp: this.#timestamp, instanceId: this.#instanceId };
+  }
+  timestamp() {
+    return { timestamp: this.#timestamp, instanceId: this.#instanceId };
+  }
+  async shutdown() {
+    clearInterval(this.#flushIntervalId);
+    await this.#flush();
+  }
+  async #appendToWal() {
+    const data = `${this.#timestamp}
+`;
+    await appendFile(_LamportClock.#WAL_FILE, data, "utf-8");
+  }
+  async #replayWal() {
+    try {
+      const data = await readFile(_LamportClock.#WAL_FILE, "utf-8");
+      return data.trim().split("\n").filter(Boolean).length;
+    } catch {
+    }
+    return 0;
+  }
+  async #loadSnapshot() {
+    try {
+      const data = await readFile(_LamportClock.#CLOCK_FILE, "utf-8");
+      return parseInt(data, 10) || 0;
+    } catch {
+    }
+    return 0;
+  }
+  async #flush() {
+    if (this.#pendingWrites === 0) {
+      return;
+    }
+    const tmp = `${_LamportClock.#CLOCK_FILE}.tmp`;
+    const data = `${this.#timestamp}
+`;
+    await writeFile(tmp, data, { flag: "w" });
+    await rename(tmp, _LamportClock.#CLOCK_FILE);
+    await writeFile(_LamportClock.#WAL_FILE, "", { flag: "w" });
+    this.#pendingWrites = 0;
+  }
+};
+
+// ../bridge-mesh/src/mesh/connections.ts
+import { EventEmitter as EventEmitter2 } from "node:events";
+var InMemoryNodeConnections = class {
+  #logger;
+  #eventEmitter = new EventEmitter2();
+  #nodes = /* @__PURE__ */ new Map();
+  #clusterNodes;
+  #lamport;
+  #timeout;
+  constructor(logger, instanceId2, timeout = 6e4) {
+    this.#logger = logger;
+    this.#clusterNodes = [instanceId2];
+    this.#lamport = new LamportClock(instanceId2);
+    this.#timeout = timeout;
+  }
+  async init(gossipTimestamp = 0) {
+    await this.#lamport.init(gossipTimestamp);
+  }
+  async close() {
+    await this.#lamport.shutdown();
+  }
+  announce(announcements) {
+    const now = Date.now();
+    for (const announcement of announcements) {
+      const { node: nodeId, users, endpoint: announcedEndpoint, metadata } = announcement;
+      const replicas = hrwHash(nodeId, this.#clusterNodes);
+      const owner = replicas[0];
+      const externalEndpoint = announcedEndpoint !== void 0 && announcedEndpoint !== `/cluster?node=${nodeId}`;
+      const endpoint = externalEndpoint ? announcedEndpoint : `/cluster?node=${nodeId}&owner=${owner}`;
+      const lamport = this.#lamport.tick();
+      const userSet = new Set(users ?? []);
+      let node = this.#nodes.get(nodeId);
+      if (!node) {
+        node = { node: nodeId, users: userSet, firstSeen: lamport, lastSeen: now, owner, replicas, endpoint, metadata };
+        this.#nodes.set(nodeId, node);
+        this.#logger.info(`${nodeId} announced at endpoint ${endpoint} with meta: ${JSON.stringify(metadata)}`);
+      }
+      node.owner = owner;
+      if (!externalEndpoint) {
+        node.endpoint = endpoint;
+      }
+      node.replicas = replicas;
+      node.lastSeen = now;
+      node.users = userSet;
+      this.#eventEmitter.emit("node-announced", nodeId, endpoint, userSet);
+    }
+    this.cleanupOldNodes();
+    const sortedNodes = this.#sortedNodeValues();
+    return announcements.map((e) => {
+      const node = this.#nodes.get(e.node);
+      const connect = this.#findConnections(sortedNodes, node);
+      return { node: node.node, owner: node.owner, connect };
+    });
+  }
+  find(nodeId) {
+    const e = this.#nodes.get(nodeId);
+    if (e !== void 0) {
+      const sortedNodes = this.#sortedNodeValues();
+      return this.#findConnections(sortedNodes, 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.#logger.info(`endpoint ${endpoint} removed for ${nodeId}`);
+      this.#eventEmitter.emit("node-deleted", nodeId, endpoint, "removed");
+      return true;
+    }
+    return false;
+  }
+  #sortedNodeValues() {
+    return Array.from(this.#nodes.values()).sort((a, b) => {
+      const diff = a.firstSeen.timestamp - b.firstSeen.timestamp;
+      if (diff === 0) {
+        return a.node.localeCompare(b.node);
+      }
+      return diff;
+    });
+  }
+  cleanupOldNodes() {
+    const threshold = Date.now() - this.#timeout;
+    for (const [nodeId, v] of this.#nodes) {
+      if (v.lastSeen < threshold) {
+        if (this.#logger.enabledFor("debug")) {
+          this.#logger.debug(`${nodeId} expired - no announcement since ${new Date(v.lastSeen).toISOString()}, timeout is ${this.#timeout} ms.`);
+        }
+        this.#nodes.delete(nodeId);
+        const endpoint = v.endpoint;
+        this.#eventEmitter.emit("node-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(sortedNodes, node) {
+    const connections = sortedNodes.reduce((l, c) => {
+      if (node !== void 0 && c.firstSeen.timestamp < node.firstSeen.timestamp) {
+        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, owner: c.owner };
+          return l.concat(e);
+        }
+      }
+      return l;
+    }, new Array());
+    if (this.#logger.enabledFor("debug")) {
+      this.#logger.debug(`found ${connections.length} connection(s) for node ${node?.node}: [${connections.map((e) => `${e.node}@${e.endpoint}`).join(", ")}]`);
+    }
+    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_);
+}
+
+// ../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 (gateway2) => {
+    const info = JSON.stringify({ ...gateway2.info(), pid: process.pid });
+    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(gateway2, bridge, env = process.env) {
+  let enabled = gateway2.enabled;
+  if (enabled === void 0) {
+    if (isRunningInConnectDesktop(env)) {
+      const applicationConfig = parseStartingContext(env)?.applicationConfig;
+      enabled = applicationConfig?.customProperties?.gatewayApp === true || applicationConfig?.name === "io-connect-gateway";
+    }
+  }
+  let contextsLifetime = gateway2.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: {
+        auth: { user: null },
+        node: "bridge-gateway",
+        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 +2573,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 +2595,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.uuid, this.config.mesh.timeout ?? 6e4);
+    this.meshChannel = new BridgeMeshChannel(relays, connections, this.getLogger("channel"));
   }
   getLogger(name) {
     return getLogger(name);
@@ -2101,6 +2617,7 @@ var BridgeNode = class {
     return setInterval(task, licenseCheckInterval);
   }
   async start() {
+    await this.meshChannel.init();
     const config = {
       port: this.config.server.port,
       host: this.config.server.host,
@@ -2108,8 +2625,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 +2636,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 +2655,7 @@ var BridgeNode = class {
       await this.discoveryService.close();
     } catch (e) {
     }
+    await this.meshChannel.close();
   }
 };
 
@@ -2234,12 +2717,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;