@mh-gg/cli 0.1.1-alpha.20260613T085325975Z

package/runtime/host/relay/peerStartup.cjs

@@ -0,0 +1,81 @@
+const { waitForPeerOpen } = require("@mh-gg/relay-runtime");
+
+function isLocalPeerIdUnavailableError(error) {
+  const type = String(error?.type || "").toLowerCase();
+  const message = String(error?.message || error || "").toLowerCase();
+  return type === "unavailable-id"
+    || type === "peer-unavailable"
+    || message.includes("unavailable-id")
+    || message.includes("id is taken")
+    || message.includes("id already taken")
+    || message.includes("is already taken")
+    || message.includes("is unavailable");
+}
+
+async function startRelayPeers({ attachConnection, config, debugRelay, mesh, peerLifecycle, peerReconnects, sfu }) {
+  if (!config.startPeer) return { roomPeer: undefined, relayPeer: undefined };
+  return startRelayPeersOnce({ attachConnection, config, debugRelay, mesh, peerLifecycle, peerReconnects, sfu }).catch(async (error) => {
+    if (!isLocalPeerIdUnavailableError(error) || typeof config.rotateRelayTransportIdentity !== "function") throw error;
+    debugRelay(`relay transport id unavailable; rotating signed relay transport identity: ${error?.message || String(error)}`);
+    config.rotateRelayTransportIdentity(error);
+    mesh.updateLocalRelayIdentity?.(config.relayAddress, config.relayMeshPeerId);
+    return startRelayPeersOnce({ attachConnection, config, debugRelay, mesh, peerLifecycle, peerReconnects, sfu });
+  });
+}
+
+async function startRelayPeersOnce({ attachConnection, config, debugRelay, mesh, peerLifecycle, peerReconnects, sfu }) {
+  const roomPeer = await config.createPeer(config.relayPeerId, config.iceServers, { signaling: config.peerJsSignaling });
+  let relayPeer;
+  try {
+    relayPeer = await config.createPeer(config.relayMeshPeerId, config.iceServers, { signaling: config.peerJsSignaling });
+  } catch (error) {
+    roomPeer?.destroy?.();
+    throw error;
+  }
+  roomPeer.MatterhornStableId = config.relayPeerId;
+  relayPeer.MatterhornStableId = config.relayMeshPeerId;
+
+  roomPeer.on("open", (id) => peerReconnects.logOpen("matterhorn room relay peer", id, roomPeer));
+  roomPeer.on("connection", (conn) => attachConnection(conn, { relayPeer: false }));
+  roomPeer.on("error", (error) => peerLifecycle.handlePeerError(roomPeer, "matterhorn room relay peer", error));
+  roomPeer.on("disconnected", () => peerLifecycle.reconnectPeer(roomPeer, "matterhorn room relay peer", "disconnected event"));
+
+  relayPeer.on("open", (id) => {
+    peerReconnects.logOpen("matterhorn relay mesh peer", id, relayPeer);
+    mesh.onRelayPeerOpen();
+  });
+  relayPeer.on("connection", (conn) => {
+    const relayPeerConnection = mesh.connectionHasRelayMetadata(conn);
+    const connectionLabel = relayPeerConnection ? "relay mesh incoming" : "relay mesh probe";
+    debugRelay(`${connectionLabel} ${conn.peer || "unknown"}`);
+    if (relayPeerConnection && mesh.activeRelayCount() >= config.activeRelayFanout) {
+      debugRelay(`relay mesh incoming rejected ${conn.peer || "unknown"}; fanout limit reached`);
+      conn.close?.();
+      return;
+    }
+    conn.on("open", () => debugRelay(`${connectionLabel} open ${conn.peer || "unknown"}`));
+    conn.on("close", () => debugRelay(`${connectionLabel} closed ${conn.peer || "unknown"}`));
+    conn.on("error", (error) => debugRelay(`${connectionLabel} error ${conn.peer || "unknown"}: ${error?.message || String(error)}`));
+    attachConnection(conn, { relayPeer: relayPeerConnection });
+  });
+  relayPeer.on("error", (error) => peerLifecycle.handlePeerError(relayPeer, "matterhorn relay mesh peer", error));
+  relayPeer.on("disconnected", () => peerLifecycle.reconnectPeer(relayPeer, "matterhorn relay mesh peer", "disconnected event"));
+
+  try {
+    await Promise.all([
+      waitForPeerOpen(roomPeer, "matterhorn room relay peer"),
+      waitForPeerOpen(relayPeer, "matterhorn relay mesh peer"),
+      sfu.start()
+    ]);
+  } catch (error) {
+    roomPeer?.destroy?.();
+    relayPeer?.destroy?.();
+    throw error;
+  }
+  return { roomPeer, relayPeer };
+}
+
+module.exports = {
+  isLocalPeerIdUnavailableError,
+  startRelayPeers
+};