@buoy-gg/sync-broker 4.0.1

package/dist/index.js

@@ -0,0 +1,482 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_BROKER_PORT: () => DEFAULT_BROKER_PORT,
+  SOCKET_CONFIG: () => SOCKET_CONFIG,
+  SYNC_PROTOCOL_VERSION: () => SYNC_PROTOCOL_VERSION,
+  createBroker: () => createBroker,
+  socketHandle: () => socketHandle
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/socketHandle.ts
+var users = [];
+var allDevices = [];
+var dashboardClients = [];
+var deviceIdMap = /* @__PURE__ */ new Map();
+var activeConnectionsMap = /* @__PURE__ */ new Map();
+var deviceCapabilities = /* @__PURE__ */ new Map();
+var dashboardWatches = /* @__PURE__ */ new Map();
+var watchCounts = /* @__PURE__ */ new Map();
+var toWatchKey = (targetDeviceId, toolId) => JSON.stringify([targetDeviceId, toolId]);
+var fromWatchKey = (key) => JSON.parse(key);
+function socketHandle({ io }) {
+  const LOG_PREFIX = "[SERVER]";
+  function handleClose(id, reason) {
+    const user = users.find((user2) => user2.id === id);
+    const deviceId = deviceIdMap.get(id);
+    if (!deviceId || !users.some((u) => u.id !== id && u.deviceId === deviceId)) {
+      users = users.filter((user2) => user2.id !== id);
+      console.log(
+        `${LOG_PREFIX} Client disconnected - ID: ${id}, Name: ${user?.deviceName || "Unknown"} - Removing user record`
+      );
+      if (deviceId) {
+        const deviceIndex = allDevices.findIndex(
+          (u) => u.deviceId === deviceId
+        );
+        if (deviceIndex !== -1) {
+          allDevices[deviceIndex].isConnected = false;
+          allDevices[deviceIndex].lastDisconnectReason = reason;
+          activeConnectionsMap.delete(deviceId);
+        }
+      }
+    } else {
+      console.log(
+        `${LOG_PREFIX} Client disconnected - ID: ${id}, Name: ${user?.deviceName || "Unknown"} - Keeping user record for same device with ID: ${deviceId}`
+      );
+    }
+    deviceIdMap.delete(id);
+    const wasDashboard = dashboardClients.includes(id);
+    dashboardClients = dashboardClients.filter((clientId) => clientId !== id);
+    releaseDashboardWatches(id);
+    console.log(
+      `${LOG_PREFIX} Client disconnected - ID: ${id}, Name: ${user?.deviceName || "Unknown"}, Was Dashboard: ${wasDashboard}, Reason: ${reason ?? "unknown"}`
+    );
+    io.emit(
+      "all-devices-update",
+      allDevices.filter((device) => device.deviceName !== "Dashboard")
+    );
+    console.log(
+      `${LOG_PREFIX} Updated users list: ${users.map((u) => u.deviceName).join(", ")}`
+    );
+  }
+  function addNewUser({
+    id,
+    deviceName,
+    deviceId,
+    platform,
+    extraDeviceInfo,
+    envVariables,
+    connectionNonce
+  }) {
+    const isDashboard = deviceName === "Dashboard";
+    if (deviceId) {
+      deviceIdMap.set(id, deviceId);
+      activeConnectionsMap.set(deviceId, id);
+      const existingUserIndex = users.findIndex(
+        (user) => user.deviceId === deviceId
+      );
+      const existingDeviceIndex = allDevices.findIndex(
+        (device) => device.deviceId === deviceId
+      );
+      if (existingUserIndex !== -1) {
+        console.log(
+          `${LOG_PREFIX} Reconnecting existing device - ID: ${id}, Name: ${deviceName}, DeviceId: ${deviceId}, Platform: ${platform || "Unknown"}, ExtraDeviceInfo: ${extraDeviceInfo}`
+        );
+        users[existingUserIndex].id = id;
+        if (platform) {
+          users[existingUserIndex].platform = platform;
+        }
+        if (extraDeviceInfo) {
+          users[existingUserIndex].extraDeviceInfo = extraDeviceInfo;
+        }
+        if (envVariables) {
+          users[existingUserIndex].envVariables = envVariables;
+        }
+        users[existingUserIndex].isConnected = true;
+        users[existingUserIndex].connectionNonce = connectionNonce;
+        if (existingDeviceIndex !== -1) {
+          allDevices[existingDeviceIndex].id = id;
+          allDevices[existingDeviceIndex].isConnected = true;
+          allDevices[existingDeviceIndex].connectionNonce = connectionNonce;
+          if (platform) {
+            allDevices[existingDeviceIndex].platform = platform;
+          }
+          if (extraDeviceInfo) {
+            allDevices[existingDeviceIndex].extraDeviceInfo = extraDeviceInfo;
+          }
+          if (envVariables) {
+            allDevices[existingDeviceIndex].envVariables = envVariables;
+          }
+        } else if (deviceName !== "Dashboard") {
+          allDevices.push({
+            id,
+            deviceName,
+            deviceId,
+            platform,
+            isConnected: true,
+            extraDeviceInfo,
+            envVariables
+          });
+        }
+        io.emit(
+          "all-devices-update",
+          allDevices.filter((device) => device.deviceName !== "Dashboard")
+        );
+        console.log(
+          `${LOG_PREFIX} Updated users list: ${users.map((u) => u.deviceName).join(", ")}`
+        );
+        return;
+      }
+    }
+    const extractNumber = (name) => {
+      const match = name.match(/(\d+)$/);
+      return match ? parseInt(match[1], 10) : 1;
+    };
+    let highestNumber = 0;
+    users.forEach((user) => {
+      if (user.deviceName.startsWith(deviceName)) {
+        const number = extractNumber(user.deviceName);
+        if (number >= highestNumber) {
+          highestNumber = number;
+        }
+      }
+    });
+    if (highestNumber > 0 && !isDashboard) {
+      deviceName = `${deviceName} #${highestNumber + 1}`;
+    }
+    if (id) {
+      const newUser = {
+        id,
+        deviceName,
+        deviceId,
+        platform,
+        isConnected: true,
+        extraDeviceInfo,
+        envVariables,
+        connectionNonce
+      };
+      users.push(newUser);
+      if (deviceName !== "Dashboard" && deviceId) {
+        const existingDeviceIndex = allDevices.findIndex(
+          (device) => device.deviceId === deviceId
+        );
+        if (existingDeviceIndex !== -1) {
+          allDevices[existingDeviceIndex] = { ...newUser };
+        } else {
+          allDevices.push({ ...newUser });
+        }
+      }
+      console.log(
+        `${LOG_PREFIX} New user connected - ID: ${id}, Name: ${deviceName}${deviceId ? `, DeviceId: ${deviceId}` : ""}${platform ? `, Platform: ${platform}` : ""}`
+      );
+      if (isDashboard && id) {
+        dashboardClients.push(id);
+        console.log(`${LOG_PREFIX} Registered dashboard client with ID: ${id}`);
+      }
+      io.emit(
+        "all-devices-update",
+        allDevices.filter((device) => device.deviceName !== "Dashboard")
+      );
+      console.log(
+        `${LOG_PREFIX} Updated device list: ${users.map((u) => u.deviceName).join(", ")}`
+      );
+    }
+  }
+  function getDeviceFromDeviceId(deviceId) {
+    return allDevices.find((device) => device.deviceId === deviceId);
+  }
+  function handleUserMessage(message, deviceName) {
+    console.log(`${LOG_PREFIX} Message from ${deviceName}: ${message}`);
+    io.emit("message", `Device ${deviceName} sent message: ${message}`);
+  }
+  function forwardToDashboards(event, message) {
+    dashboardClients = dashboardClients.filter(
+      (id) => io.sockets.sockets.has(id)
+    );
+    if (dashboardClients.length === 0) {
+      return;
+    }
+    for (const dashboardId of dashboardClients) {
+      io.sockets.sockets.get(dashboardId)?.emit(event, message);
+    }
+  }
+  function withTargetUsers(targetDeviceId, action, actionName) {
+    const deviceName = getDeviceFromDeviceId(targetDeviceId)?.deviceName;
+    if (targetDeviceId === "No devices available") {
+      console.log(
+        `${LOG_PREFIX} Skipping ${actionName} - No devices available`
+      );
+      return;
+    }
+    if (targetDeviceId === "All") {
+      console.log(`${LOG_PREFIX} Broadcasting ${actionName} to all devices`);
+      const deviceUsers = users.filter(
+        (user) => user.deviceName !== "Dashboard"
+      );
+      console.log(
+        `${LOG_PREFIX} Sending to ${deviceUsers.length} devices: ${deviceUsers.map((u) => u.deviceName).join(", ")}`
+      );
+      deviceUsers.forEach(action);
+    } else {
+      const targetUser = users.find((user) => user.deviceId === targetDeviceId);
+      if (targetUser) {
+        console.log(
+          `${LOG_PREFIX} Sending to target device ${targetUser.deviceName} (${targetUser.deviceId}) targetDeviceId: ${targetDeviceId}`
+        );
+        action(targetUser);
+      } else {
+        console.log(
+          `${LOG_PREFIX} Target device not found - DeviceId: ${targetDeviceId}, DeviceName: ${deviceName}`
+        );
+      }
+    }
+  }
+  function handleDevtoolWatch(dashboardId, message) {
+    const key = toWatchKey(message.targetDeviceId, message.toolId);
+    let watches = dashboardWatches.get(dashboardId);
+    if (!watches) {
+      watches = /* @__PURE__ */ new Set();
+      dashboardWatches.set(dashboardId, watches);
+    }
+    if (message.watching) {
+      if (!watches.has(key)) {
+        watches.add(key);
+        watchCounts.set(key, (watchCounts.get(key) ?? 0) + 1);
+      }
+      console.log(
+        `${LOG_PREFIX} Dashboard ${dashboardId} watching "${message.toolId}" on ${message.targetDeviceId}`
+      );
+      withTargetUsers(
+        message.targetDeviceId,
+        (user) => io.to(user.id).emit("devtool-watch", message),
+        `devtool watch ${message.toolId}`
+      );
+    } else if (watches.has(key)) {
+      watches.delete(key);
+      decrementWatch(key);
+    }
+  }
+  function decrementWatch(key) {
+    const next = (watchCounts.get(key) ?? 1) - 1;
+    if (next > 0) {
+      watchCounts.set(key, next);
+      return;
+    }
+    watchCounts.delete(key);
+    const [targetDeviceId, toolId] = fromWatchKey(key);
+    console.log(
+      `${LOG_PREFIX} Last dashboard stopped watching "${toolId}" on ${targetDeviceId}`
+    );
+    withTargetUsers(
+      targetDeviceId,
+      (user) => io.to(user.id).emit("devtool-watch", { toolId, targetDeviceId, watching: false }),
+      `devtool unwatch ${toolId}`
+    );
+  }
+  function releaseDashboardWatches(dashboardId) {
+    const watches = dashboardWatches.get(dashboardId);
+    if (!watches) return;
+    dashboardWatches.delete(dashboardId);
+    for (const key of watches) {
+      decrementWatch(key);
+    }
+  }
+  io.on("connection", (socket) => {
+    const {
+      deviceName,
+      deviceId,
+      platform,
+      extraDeviceInfo,
+      envVariables,
+      connectionNonce
+    } = socket.handshake.query;
+    console.log(
+      `${LOG_PREFIX} New connection - ID: ${socket.id}, Name: ${deviceName || "Unknown Device"}${deviceId ? `, DeviceId: ${deviceId}` : ""}${platform ? `, Platform: ${platform}` : ""}${extraDeviceInfo ? `, ExtraDeviceInfo: ${extraDeviceInfo}` : ""}${envVariables ? `, EnvVariables: ${envVariables}` : ""}`
+    );
+    addNewUser({
+      id: socket.id,
+      deviceName: deviceName || "Unknown Device Name",
+      deviceId,
+      platform,
+      extraDeviceInfo,
+      envVariables,
+      connectionNonce
+    });
+    if (deviceName === "Dashboard") {
+      for (const capabilities of deviceCapabilities.values()) {
+        socket.emit("devtool-capabilities", capabilities);
+      }
+    }
+    socket.on(
+      "device-license",
+      (payload) => {
+        const nextIsPro = payload?.isPro === "1" || payload?.isPro === true;
+        const nextKey = payload?.licenseKey || void 0;
+        const user = users.find((u) => u.id === socket.id);
+        if (user) {
+          user.isPro = nextIsPro;
+          user.licenseKey = nextIsPro ? nextKey : void 0;
+        }
+        const did = user?.deviceId || deviceIdMap.get(socket.id);
+        if (did) {
+          const device = allDevices.find((d) => d.deviceId === did);
+          if (device) {
+            device.isPro = nextIsPro;
+            device.licenseKey = nextIsPro ? nextKey : void 0;
+          }
+        }
+        console.log(
+          `${LOG_PREFIX} device-license from ${user?.deviceName || socket.id}: isPro=${nextIsPro}${nextKey ? ", key set" : ""}`
+        );
+        io.emit(
+          "all-devices-update",
+          allDevices.filter((device) => device.deviceName !== "Dashboard")
+        );
+      }
+    );
+    socket.on(
+      "disconnect",
+      (reason) => handleClose(socket.id, reason)
+    );
+    socket.on("message", (msg) => {
+      handleUserMessage(msg, deviceName || "Unknown");
+    });
+    socket.on("devtool-capabilities", (message) => {
+      console.log(
+        `${LOG_PREFIX} Capabilities from ${message.persistentDeviceId}: ${message.tools.map((tool) => `${tool.toolId}@v${tool.version}`).join(", ")}`
+      );
+      deviceCapabilities.set(message.persistentDeviceId, message);
+      forwardToDashboards("devtool-capabilities", message);
+      for (const key of watchCounts.keys()) {
+        const [targetDeviceId, toolId] = fromWatchKey(key);
+        if (targetDeviceId === "All" || targetDeviceId === message.persistentDeviceId) {
+          socket.emit("devtool-watch", {
+            toolId,
+            targetDeviceId,
+            watching: true
+          });
+        }
+      }
+    });
+    socket.on("devtool-sync", (message) => {
+      forwardToDashboards("devtool-sync", message);
+    });
+    socket.on(
+      "devtool-action-result",
+      (message) => {
+        console.log(
+          `${LOG_PREFIX} Action result from ${message.persistentDeviceId}: ${message.toolId}.${message.action} -> ${message.ok ? "ok" : `error: ${message.error}`}`
+        );
+        forwardToDashboards("devtool-action-result", message);
+      }
+    );
+    socket.on("devtool-watch", (message) => {
+      handleDevtoolWatch(socket.id, message);
+    });
+    socket.on("request-devtool-state", (message) => {
+      withTargetUsers(
+        message.targetDeviceId,
+        (user) => io.to(user.id).emit("request-devtool-state", message),
+        `devtool state request ${message.toolId}`
+      );
+    });
+    socket.on("devtool-action", (message) => {
+      console.log(
+        `${LOG_PREFIX} Devtool action from dashboard: ${message.toolId}.${message.action} -> ${message.targetDeviceId}`
+      );
+      withTargetUsers(
+        message.targetDeviceId,
+        (user) => io.to(user.id).emit("devtool-action", message),
+        `devtool action ${message.toolId}.${message.action}`
+      );
+    });
+  });
+}
+
+// src/createBroker.ts
+var import_http = __toESM(require("http"));
+var import_socket = require("socket.io");
+var DEFAULT_BROKER_PORT = 42831;
+var SOCKET_CONFIG = {
+  cors: {
+    origin: "*",
+    methods: ["GET", "POST"]
+  },
+  // Dev-tool snapshots are whole app-state dumps (a dehydrated React Query
+  // cache, a Redux/Zustand store, an aggregated event log, etc.) and a device
+  // pushes one per watched tool on connect. socket.io v3+ caps inbound messages
+  // at 1 MB by default and TERMINATES the connection ("transport error") when a
+  // single message exceeds it — which, with a dashboard watching all ~11 tools
+  // at once, makes a device's connection flap. These are local, trusted dev
+  // connections, so lift the cap well clear of any realistic state dump.
+  maxHttpBufferSize: 1e8,
+  // 100 MB
+  transports: ["websocket", "polling"],
+  pingTimeout: 3e4,
+  pingInterval: 25e3
+};
+function createBroker(options = {}) {
+  const port = options.port ?? DEFAULT_BROKER_PORT;
+  const httpServer = import_http.default.createServer((_req, res) => {
+    res.writeHead(200, { "content-type": "text/plain" });
+    res.end(`Buoy sync broker running on port ${port}`);
+  });
+  const io = new import_socket.Server(httpServer, {
+    ...SOCKET_CONFIG,
+    ...options.socketOptions
+  });
+  socketHandle({ io });
+  httpServer.on("error", (error) => {
+    options.onError?.(error);
+  });
+  httpServer.listen(port, () => {
+    options.onListening?.(port);
+  });
+  const close = () => new Promise((resolve) => {
+    io.close(() => {
+      httpServer.close(() => resolve());
+    });
+  });
+  return { io, httpServer, port, close };
+}
+
+// src/protocol.ts
+var SYNC_PROTOCOL_VERSION = 1;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_BROKER_PORT,
+  SOCKET_CONFIG,
+  SYNC_PROTOCOL_VERSION,
+  createBroker,
+  socketHandle
+});