@interopio/bridge 1.0.5 → 1.0.6

package/changelog.md

@@ -2,6 +2,15 @@
 
 # Change Log
 
+## 1.0.6 (2025-12-05)
+### Changed
+- bump @interopio/gateway-server to 0.19.3
+- bump @interopio/gateway to 0.22.3 (fix log)
+- embedded gateway now uses bridge node id as gateway node id
+
+### Added
+- start management pipe when connect desktop is detected 
+
 ## 1.0.5 (2025-11-23)
 ### Changed
 - bump @interopio/gateway-server to 0.19.1

package/dist/main.js

@@ -1361,7 +1361,7 @@ function parseVersion(version) {
 // package.json
 var package_default = {
   name: "@interopio/bridge",
-  version: "1.0.5",
+  version: "1.0.6",
   license: "see license in license.md",
   author: "interop.io",
   homepage: "https://docs.interop.io/bridge",
@@ -1401,14 +1401,14 @@ var package_default = {
     build: "npm run build:main && npm run build:index"
   },
   dependencies: {
-    "@interopio/gateway-server": "^0.19.1",
+    "@interopio/gateway-server": "^0.19.3",
     dotenv: "^17.2.3",
     jsrsasign: "^11.1.0",
     "hrw-hash": "^2.0.3",
     nanoid: "^5.1.6"
   },
   devDependencies: {
-    "@interopio/gateway": "^0.22.1",
+    "@interopio/gateway": "^0.22.3",
     "@types/jsrsasign": "^10.5.15",
     "@types/ws": "^8.18.1",
     "rand-seed": "^3.0.0"
@@ -1486,7 +1486,7 @@ var DefaultAddressPicker = class {
   #publicAddressConfig;
   #publicAddress;
   #bindAddress;
-  server;
+  #server;
   #port;
   constructor(config, logger) {
     this.#logger = logger;
@@ -1494,6 +1494,17 @@ var DefaultAddressPicker = class {
     this.#port = config.network.port;
     this.#publicAddressConfig = config.network.publicAddress;
   }
+  async close() {
+    await new Promise((resolve, reject) => {
+      this.#server.close((err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
   async pickAddress() {
     if (this.#publicAddress || this.#bindAddress) {
       return;
@@ -1505,12 +1516,12 @@ var DefaultAddressPicker = class {
     return this.#publicAddress;
   }
   getServers() {
-    return /* @__PURE__ */ new Map([["member", this.server]]);
+    return /* @__PURE__ */ new Map([["member", this.#server]]);
   }
   async getPublicAddressByPortSearch() {
     const bindAddressDef = await this.pickAddressDef();
-    this.server = await createNetServer(this.#logger, "0.0.0.0", bindAddressDef.port === 0 ? this.#port : bindAddressDef.port);
-    const port = this.server.address().port;
+    this.#server = await createNetServer(this.#logger, "0.0.0.0", bindAddressDef.port === 0 ? this.#port : bindAddressDef.port);
+    const port = this.#server.address().port;
     this.#bindAddress = await createAddress(bindAddressDef, port);
     return this.getPublicAddress(port);
   }
@@ -2358,10 +2369,10 @@ var InMemoryNodeConnections = class {
       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);
+      const userSet = new Set(users ?? []);
       if (!node) {
+        const lamport = this.#lamport.tick();
         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)}`);
@@ -2424,9 +2435,10 @@ var InMemoryNodeConnections = class {
     });
   }
   #cleanupOldNodes() {
-    const expiredTimestamp = Date.now() - this.#timeout;
-    const removedTimestamp = Date.now() - this.#timeout * 2;
-    const compactTimestamp = Date.now() - this.#timeout * 10;
+    const now = Date.now();
+    const expiredTimestamp = now - this.#timeout;
+    const removedTimestamp = now - this.#timeout * 2;
+    const compactTimestamp = now - this.#timeout * 10;
     for (const [nodeId, v] of this.#nodes) {
       if (v.lastSeen < compactTimestamp && v.status === "removed") {
         if (this.#logger.enabledFor("debug")) {
@@ -2497,29 +2509,171 @@ function parseStartingContext(env = process.env) {
 }
 
 // ../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) => {
+
+// ../bridge-gateway/src/pipes/common.ts
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+function isWinOS() {
+  return process.platform === "win32";
+}
+function getPipeFileName(pipe) {
+  return isWinOS() ? `\\\\.\\pipe\\${pipe}` : join(tmpdir(), `${pipe}.sock`);
+}
+
+// ../bridge-gateway/src/pipes/discovery.ts
+import { createServer as createServer2 } from "node:net";
+function getDiscoveryPipeFileName({ environment, region, user }) {
+  return getPipeFileName(`glue42-${environment}-${region}-${user}`);
+}
+function gatewayDiscoveryPipeServer({ logger, info, pipeNameProps }) {
+  const pipeName = getDiscoveryPipeFileName(pipeNameProps);
+  logger.info(`gateway started: ${info}, opening ${pipeName}`);
+  const server = createServer2((stream) => {
+    logger.info(`stream connected, sending info...`);
+    stream.write(info);
+    stream.end(() => {
+      server.close();
+    });
+  });
+  server.listen(pipeName);
+  return server;
+}
+
+// ../bridge-gateway/src/pipes/command.ts
+import { createServer as createServer3 } from "node:net";
+function getGWPipeFileName({ environment, region, user }) {
+  return getPipeFileName(`glue42-gateway-${environment}-${region}-${user}`);
+}
+function createPipeCommandServer({ logger, pipeName, handler, onClose }) {
+  if (logger.enabledFor("info")) {
+    logger.info(`[${pipeName}] opening command server pipe, waiting for the data...`);
+  }
+  try {
+    const server = createServer3((stream) => {
+      if (logger.enabledFor("debug")) {
+        logger.debug(`[${pipeName}] command pipe server got client, waiting for the data...`);
+      }
+      stream.on("close", () => {
+        if (logger.enabledFor("debug")) {
+          logger.debug(`[${pipeName}] client closed`);
+        }
+      });
+      stream.on("error", (error) => {
+        logger.error(`[${pipeName}] error on pipe stream`, error);
+      });
+      stream.on("data", async (...args) => {
+        try {
+          const asString = args.toString();
+          const msg = JSON.parse(asString);
+          if (logger.enabledFor("info")) {
+            logger.info(`[${pipeName}] received command ${msg.command}`);
+          }
+          handler(msg).then((result) => {
+            const response = JSON.stringify({ result });
+            if (logger.enabledFor("info")) {
+              logger.info(`[${pipeName}] command ${msg.command} processed successfully. sending : ${response}`);
+            }
+            stream.write(response, (e) => {
+              if (e) {
+                if (logger.enabledFor("debug")) {
+                  logger.debug(`[${pipeName}] error while sending response for command ${msg.command}`, e);
+                }
+              }
+            });
+          }).catch((error) => {
+            const response = JSON.stringify({ error: error.message });
+            logger.error(`[${pipeName}] processing command ${msg.command} failed, sending ${response}`, error);
+            stream.write(response, (e) => {
+              if (e) {
+                if (logger.enabledFor("debug")) {
+                  logger.debug(`[${pipeName}] error while sending error response for command ${msg.command}`, e);
+                }
+              }
+            });
+          }).finally(() => {
+            if (msg.command === "shutdown") {
+              if (logger.enabledFor("info")) {
+                logger.info(`[${pipeName}] stopping management pipe server`);
+              }
+              server.close(onClose);
+            }
+          });
+        } catch (error) {
+          logger.error(`[${pipeName}] unable to parse the data`, error);
+        }
+      });
+    });
+    server.on("listening", () => {
+      if (logger.enabledFor("info")) {
+        logger.info(`[${pipeName}] connected to the pipe, waiting for the data...`);
+      }
+    });
+    server.on("error", (error) => {
+      logger.error(`[${pipeName}] error while opening the pipe - ${pipeName}`, error);
+      throw error;
+    });
+    server.listen(pipeName);
+  } catch (cause) {
+    const msg = `error while opening the pipe - ${pipeName}`;
+    logger.error(msg, cause);
+    const error = new Error(msg);
+    error.cause = cause;
+    throw error;
+  }
+}
+function gatewayCommandPipeServer({ logger, shutdownHandler, info, pipeNameProps }) {
+  const pipeName = getGWPipeFileName(pipeNameProps);
+  createPipeCommandServer({
+    pipeName,
+    logger,
+    onClose: () => {
+      if (logger.enabledFor("info")) {
+        logger.info(`[${pipeName}] command server closed, exiting bridge process`);
+      }
+      process.exit(0);
+    },
+    handler: async (msg) => {
+      if (msg.command === "shutdown") {
+        await shutdownHandler?.();
+        return "gateway stopped";
+      } else if (msg.command === "get-info") {
+        return info;
+      } else if (msg.command === "update-auth") {
+        if (msg.auth) {
+          throw new Error("auth update not implemented");
+        } else {
+          throw new Error("no auth provided");
+        }
+      }
+    }
+  });
+}
+
+// ../bridge-gateway/src/index.ts
+function onGatewayStarted(log, env = process.env) {
+  return (gateway2, shutdownHandler) => {
     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);
+      const startingContext = parseStartingContext(env);
+      const environment = startingContext.env ?? env.IO_CD_ENV ?? env["GLUE-ENV"] ?? "DEMO";
+      const region = startingContext.region ?? env.IO_CD_REGION ?? env["GLUE-REGION"] ?? "INTEROP.IO";
+      const user = env.USERNAME ?? env.USER;
+      let discoveryServer;
+      const options = {
+        logger: log,
+        shutdownHandler: async () => {
+          if (discoveryServer) {
+            discoveryServer.close();
+          }
+          return await shutdownHandler();
+        },
+        info,
+        pipeNameProps: { environment, region, user }
+      };
+      discoveryServer = gatewayDiscoveryPipeServer(options);
+      gatewayCommandPipeServer(options);
     } else {
       log.info(`gateway started: ${info}`);
     }
@@ -2529,7 +2683,7 @@ async function serverGatewayConfig(gateway2, bridge, env = process.env) {
   let enabled = gateway2.enabled;
   if (enabled === void 0) {
     if (isRunningInConnectDesktop(env)) {
-      const applicationConfig = parseStartingContext(env)?.applicationConfig;
+      const applicationConfig = parseStartingContext(env).applicationConfig;
       enabled = applicationConfig?.customProperties?.gatewayApp === true || applicationConfig?.name === "io-connect-gateway";
     }
   }
@@ -2541,14 +2695,13 @@ async function serverGatewayConfig(gateway2, bridge, env = process.env) {
   }
   if (enabled) {
     return {
-      // globals: { websocket },
       clients: {
         inactive_seconds: 0
       },
       ping: bridge.wsPingInterval ?? void 0,
       mesh: {
         auth: { user: null },
-        node: "bridge-gateway",
+        node: bridge.uuid,
         channel: bridge.meshChannel
       },
       contexts: {
@@ -2610,6 +2763,7 @@ var BridgeNode = class {
   version;
   server;
   licenseValidator;
+  #licenseCheckIntervalId;
   constructor(config) {
     this.config = config;
     this.licenseValidator = BridgeLicenseValidator(this.getLogger("license"));
@@ -2624,6 +2778,8 @@ var BridgeNode = class {
         uuid: this.uuid,
         version: this.version
       };
+    }).finally(() => {
+      addressPicker.close();
     });
     const joinConfig = config.network.join;
     const isAutoDetectionEnabled = joinConfig.autoDetectionEnabled;
@@ -2636,7 +2792,7 @@ var BridgeNode = class {
   getLogger(name) {
     return getLogger(name);
   }
-  async scheduleLicenseCheck() {
+  scheduleLicenseCheck() {
     const task = async () => {
       try {
         this.licenseValidator.validate(this.config.license, {
@@ -2669,16 +2825,22 @@ var BridgeNode = class {
       auth: { type: "none", ...this.config.server.auth },
       cors: this.config.server.cors.disabled ? false : this.config.server.cors
     };
-    config.gateway = await serverGatewayConfig(this.config.gateway, { meshChannel: this.meshChannel, wsPingInterval: this.config.server.wsPingInterval });
+    config.gateway = await serverGatewayConfig(this.config.gateway, {
+      meshChannel: this.meshChannel,
+      wsPingInterval: this.config.server.wsPingInterval,
+      uuid: this.uuid
+    });
     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);
+      onGatewayStarted(this.getLogger("gw"))(this.server.gateway, async () => {
+        await this.stop();
+      });
     }
-    await this.scheduleLicenseCheck();
+    this.#licenseCheckIntervalId = this.scheduleLicenseCheck();
   }
   async stop() {
     if (this.server) {
@@ -2689,6 +2851,10 @@ var BridgeNode = class {
     } catch (e) {
     }
     await this.meshChannel.close();
+    if (this.#licenseCheckIntervalId !== void 0) {
+      clearInterval(this.#licenseCheckIntervalId);
+      this.#licenseCheckIntervalId = void 0;
+    }
   }
 };