@interopio/bridge 0.1.0-beta.0 → 1.0.1

package/dist/main.js

@@ -35,8 +35,8 @@ var InternalRelays = class {
     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(", ")}`);
+        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);
@@ -44,8 +44,8 @@ var InternalRelays = class {
     }
   }
   #connect(key, node) {
-    if (this.#logger.enabledFor("debug")) {
-      this.#logger.debug(`${key} registers node ${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);
@@ -72,6 +72,25 @@ var InternalRelays = class {
           }
         }
         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 };
@@ -86,23 +105,28 @@ var InternalRelays = class {
     return this;
   }
   send(key, node, msg, cb) {
-    if (this.#logger.enabledFor("debug")) {
+    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;
     {
-      const senderLinkData = this.#links.get(decoded.from);
-      switch (decoded.type) {
+      node ??= decoded.to;
+      const link = decoded.from;
+      const type = decoded.type;
+      const senderLinkData = this.#links.get(link);
+      switch (type) {
         case "hello":
-          if (node === decoded.to) {
-            senderLinkData?.linksByNode.set(decoded.to, key);
+          if (this.#logger.enabledFor("debug")) {
+            this.#logger.debug(`${key} connecting ${link} to ${node}`);
           }
+          senderLinkData?.linksByNode.set(node, key);
           break;
         case "bye":
-          if (node === decoded.to) {
-            senderLinkData?.linksByNode.delete(decoded.to);
+          if (this.#logger.enabledFor("debug")) {
+            this.#logger.debug(`${key} disconnecting ${link} from ${node}`);
           }
+          senderLinkData?.linksByNode.delete(node);
           break;
       }
     }
@@ -116,6 +140,9 @@ var InternalRelays = class {
         }
       }
     }
+    if (decoded.type === "bye") {
+      return;
+    }
     throw new Error(`${key} no active link for ${node}`);
   }
 };
@@ -1334,7 +1361,7 @@ function parseVersion(version) {
 // package.json
 var package_default = {
   name: "@interopio/bridge",
-  version: "0.1.0-beta.0",
+  version: "1.0.1",
   license: "see license in license.md",
   author: "interop.io",
   homepage: "https://docs.interop.io/bridge",
@@ -1347,7 +1374,7 @@ var package_default = {
   ],
   repository: {
     type: "git",
-    url: "https://github.com/InteropIO/bridge.git",
+    url: "git+https://github.com/InteropIO/bridge.git",
     directory: "packages/bridge"
   },
   type: "module",
@@ -1364,7 +1391,7 @@ var package_default = {
     }
   },
   bin: {
-    bridge: "./bin/bridge.js"
+    bridge: "bin/bridge.js"
   },
   scripts: {
     test: "mocha test --recursive",
@@ -1374,13 +1401,14 @@ var package_default = {
     build: "npm run build:main && npm run build:index"
   },
   dependencies: {
-    "@interopio/gateway-server": "^0.13.0-beta.1",
+    "@interopio/gateway-server": "^0.17.0",
     dotenv: "^17.2.3",
     jsrsasign: "^11.1.0",
+    "hrw-hash": "^2.0.3",
     nanoid: "^5.1.6"
   },
   devDependencies: {
-    "@interopio/gateway": "^0.16.1-beta.0",
+    "@interopio/gateway": "^0.20.0",
     "@types/jsrsasign": "^10.5.15",
     "@types/ws": "^8.18.1",
     "rand-seed": "^3.0.0"
@@ -1759,9 +1787,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");
@@ -1827,9 +1859,10 @@ 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}`);
+    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);
@@ -1869,7 +1902,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}`);
       }
     });
@@ -1897,7 +1930,7 @@ async function create2(log, relays, env) {
               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}`);
             }
           });
@@ -1924,7 +1957,7 @@ async function create2(log, relays, env) {
     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);
@@ -1969,6 +2002,7 @@ import "@interopio/gateway-server";
 
 // ../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;
@@ -1997,6 +2031,7 @@ var BridgeMeshChannel = class {
       throw new Error(`already subscribed to node ${node}`);
     }
     this.#state.set(node, { subscriber, users: /* @__PURE__ */ new Set(), members: /* @__PURE__ */ new Set() });
+    this.#announce(node);
     this.#relays.receive(key, { type: "hello", from: node, to: "all" });
     this.#relays.add(key, this.createRelayClient(key, node));
     this.#intervalId ??= setInterval(() => this.#announce(), 3e4);
@@ -2136,23 +2171,38 @@ var BridgeMeshChannel = class {
     this.#state.delete(node);
     this.#connections.remove(node);
   }
-  close() {
+  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);
-  const endpoint = `/cluster?node=${node}`;
-  return { node, endpoint, users };
+  return { node, users, metadata: { version: gateway.version, type: "io.Bridge" } };
 };
 
 // ../bridge-mesh/src/index.ts
 function connectNodeRelays(logger, relays, connections) {
+  relays.on("connect", (key, node) => {
+    try {
+      connections.add(node);
+    } catch (e) {
+      logger.warn(`${key} error adding node ${node} to connections: ${e}`);
+    }
+  });
   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) => {
@@ -2161,11 +2211,11 @@ function connectNodeRelays(logger, relays, connections) {
             return;
           }
           if (logger.enabledFor("debug")) {
-            logger.debug(`${k} sent 'bye' msg to ${linkNode}`);
+            logger.debug(`${k} sent 'bye' msg to ${linkNode} from ${node}`);
           }
         });
       } catch (err) {
-        logger.warn(`${linkKey} exception writing 'bye' msg to ${linkNode}: ${err}`);
+        logger.warn(`${linkKey} exception writing 'bye' msg to ${linkNode} from ${node}: ${err}`);
       }
     }
   });
@@ -2198,123 +2248,205 @@ var mesh = async (options, configurer, config) => {
 };
 
 // ../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]);
-    }
+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);
   }
-  get(key) {
-    const idx = this.#binarySearch(key);
-    return idx >= 0 ? this.#elements[idx][1] : void 0;
+  async init(gossipTimestamp = 0) {
+    const baseTimestamp = await this.#loadSnapshot();
+    const journaledIncrements = await this.#replayWal();
+    this.#timestamp = Math.max(baseTimestamp + journaledIncrements, gossipTimestamp);
   }
-  has(key) {
-    return this.#binarySearch(key) >= 0;
+  tick() {
+    this.#timestamp += 1;
+    this.#pendingWrites += 1;
+    this.#appendToWal().catch((_err) => {
+    });
+    return { timestamp: this.#timestamp, instanceId: this.#instanceId };
   }
-  delete(key) {
-    const idx = this.#binarySearch(key);
-    if (idx >= 0) {
-      this.#elements.splice(idx, 1);
-      return true;
+  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 false;
+    return 0;
   }
-  entries() {
-    return this.#elements[Symbol.iterator]();
+  async #loadSnapshot() {
+    try {
+      const data = await readFile(_LamportClock.#CLOCK_FILE, "utf-8");
+      return parseInt(data, 10) || 0;
+    } catch {
+    }
+    return 0;
   }
-  values() {
-    return this.#elements.map((e) => e[1]);
+  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 = new OrderedMap();
-  #nodesByEndpoint = /* @__PURE__ */ new Map();
+  #nodes = /* @__PURE__ */ new Map();
+  #clusterNodes;
+  #lamport;
   #timeout;
-  constructor(logger, timeout = 6e4) {
+  constructor(logger, instanceId2, timeout = 6e4) {
     this.#logger = logger;
+    this.#clusterNodes = [instanceId2];
+    this.#lamport = new LamportClock(instanceId2);
     this.#timeout = timeout;
   }
-  announce(nodes) {
+  async init(gossipTimestamp = 0) {
+    await this.#lamport.init(gossipTimestamp);
+  }
+  async close() {
+    await this.#lamport.shutdown();
+  }
+  announce(announcements) {
     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);
+    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, status: "announced" };
+        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;
       }
-      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 };
+      node.replicas = replicas;
+      node.lastSeen = now;
+      if (!(node.status === "announced" || node.status === "added")) {
+        node.status = "announced";
+      }
+      node.users = userSet;
+      this.#eventEmitter.emit("node-announced", nodeId, endpoint, userSet);
+    }
+    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) {
-      return this.findConnections(e);
+      const sortedNodes = this.#sortedNodeValues();
+      return this.#findConnections(sortedNodes, e);
     }
     return void 0;
   }
+  add(nodeId) {
+    const added = this.#nodes.get(nodeId);
+    if (added !== void 0 && (added.status === "announced" || added.status === "removed")) {
+      added.status = "added";
+      this.#logger.info(`endpoint ${added.endpoint} connected for ${nodeId}`);
+      this.#eventEmitter.emit("node-connected", nodeId);
+      return true;
+    }
+    return false;
+  }
   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");
+    if (removed !== void 0 && (removed.status === "announced" || removed.status === "added")) {
+      removed.status = "removed";
+      this.#logger.info(`endpoint ${removed.endpoint} removed for ${nodeId}`);
+      this.#eventEmitter.emit("node-disconnected", nodeId, "removed");
       return true;
     }
     return false;
   }
-  updateNode(newNode, users, _key, lastAccess, oldNode) {
-    const node = oldNode ?? { ...newNode };
-    return { ...node, users, lastAccess };
+  #sortedNodeValues() {
+    this.#cleanupOldNodes();
+    return Array.from(this.#nodes.values()).filter((n) => n.status === "announced" || n.status === "added").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.entries()) {
-      if (v.lastAccess < threshold) {
+  #cleanupOldNodes() {
+    const expiredTimestamp = Date.now() - this.#timeout;
+    const removedTimestamp = Date.now() - this.#timeout * 2;
+    const compactTimestamp = Date.now() - this.#timeout * 10;
+    for (const [nodeId, v] of this.#nodes) {
+      if (v.lastSeen < compactTimestamp && v.status === "removed") {
         if (this.#logger.enabledFor("debug")) {
-          this.#logger.debug(`${nodeId} expired - no announcement since ${new Date(v.lastAccess).toISOString()}, timeout is ${this.#timeout} ms.`);
+          this.#logger.debug(`${nodeId} compact - no announcement since ${new Date(v.lastSeen).toISOString()}, timeout is ${this.#timeout} ms and status is ${v.status}.`);
         }
         this.#nodes.delete(nodeId);
-        const endpoint = v.endpoint;
-        this.#nodesByEndpoint.delete(endpoint);
-        this.#eventEmitter.emit("endpoint-deleted", nodeId, endpoint, "expired");
+      }
+      if (v.lastSeen < removedTimestamp && v.status === "expired") {
+        if (this.#logger.enabledFor("debug")) {
+          this.#logger.debug(`${nodeId} removed - no announcement since ${new Date(v.lastSeen).toISOString()}, timeout is ${this.#timeout} ms.`);
+        }
+        v.status = "removed";
+      }
+      if (v.lastSeen < expiredTimestamp && (v.status === "announced" || v.status === "added")) {
+        if (this.#logger.enabledFor("debug")) {
+          this.#logger.debug(`${nodeId} expired - no announcement since ${new Date(v.lastSeen).toISOString()}, timeout is ${this.#timeout} ms.`);
+        }
+        v.status = "expired";
+        this.#eventEmitter.emit("node-disconnected", nodeId, "expired");
       }
     }
   }
@@ -2326,26 +2458,29 @@ var InMemoryNodeConnections = class {
     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);
+  #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 (!value.users.has(user)) {
+          if (!c.users.has(user)) {
             intersection.delete(user);
           }
         });
-        value.users.forEach((user) => {
+        c.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);
+          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;
   }
@@ -2359,7 +2494,7 @@ 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;
+  return JSON.parse(env._GD_STARTING_CONTEXT_);
 }
 
 // ../bridge-gateway/src/index.ts
@@ -2369,8 +2504,8 @@ import { join } from "node:path";
 import "@interopio/gateway";
 import "@interopio/gateway-server";
 function onGatewayStarted(log) {
-  return (gateway) => {
-    const info = JSON.stringify(gateway.info());
+  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";
@@ -2391,14 +2526,15 @@ function onGatewayStarted(log) {
     }
   };
 }
-async function serverGatewayConfig(gateway, bridge, env = process.env) {
-  let enabled = gateway.enabled;
+async function serverGatewayConfig(gateway2, bridge, env = process.env) {
+  let enabled = gateway2.enabled;
   if (enabled === void 0) {
     if (isRunningInConnectDesktop(env)) {
-      enabled = parseStartingContext(env)?.gatewayApp === true;
+      const applicationConfig = parseStartingContext(env)?.applicationConfig;
+      enabled = applicationConfig?.customProperties?.gatewayApp === true || applicationConfig?.name === "io-connect-gateway";
     }
   }
-  let contextsLifetime = gateway.contexts.lifetime;
+  let contextsLifetime = gateway2.contexts.lifetime;
   if (contextsLifetime === void 0) {
     if (isRunningInConnectDesktop(env)) {
       contextsLifetime = "retained";
@@ -2412,6 +2548,8 @@ async function serverGatewayConfig(gateway, bridge, env = process.env) {
       },
       ping: bridge.wsPingInterval ?? void 0,
       mesh: {
+        auth: { user: null },
+        node: "bridge-gateway",
         channel: bridge.meshChannel
       },
       contexts: {
@@ -2493,7 +2631,7 @@ var BridgeNode = class {
     const discoveryConfig = joinConfig.discovery;
     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);
+    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) {
@@ -2513,6 +2651,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,
@@ -2550,7 +2689,7 @@ var BridgeNode = class {
       await this.discoveryService.close();
     } catch (e) {
     }
-    this.meshChannel.close();
+    await this.meshChannel.close();
   }
 };