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

package/runtime/host/relay.cjs

@@ -0,0 +1,653 @@
+#!/usr/bin/env node
+
+const WebSocket = require("ws");
+const { createRelaySfu } = require("./sfuRelay.cjs");
+const { WebSocketRelayConnection } = require("@mh-gg/host-ipc");
+const {
+  createEncryptedRoomRuntimeManager,
+  createPeerReconnectTracker,
+  createRelayPluginRuntimeManager,
+  isNewerRoomState,
+  waitForPeerOpen
+} = require("@mh-gg/relay-runtime");
+const {
+  createRelayInformation,
+  createRelayChunkAssembler,
+  isRelayChunk,
+  isNostrMessage,
+  peerJsOptionsFromAddress,
+  sendMessage
+} = require("@mh-gg/relay-core");
+const {
+  createRelayMeshRouter
+} = require("@mh-gg/relay-mesh");
+const { createRelayHttpServer } = require("./relayHttp.cjs");
+const { createRelayClientRouting } = require("./relayClientRouting.cjs");
+const { createPushStorage } = require("./pushStorage.cjs");
+const { createPushEgress } = require("./pushEgress.cjs");
+const { createRelayHostAuth } = require("./relayHostAuth.cjs");
+const { createRelayHostMessageHandler } = require("./relayHostMessages.cjs");
+const { createRelayIncomingGate, isRelayEnvelopeMessage } = require("./relayIncomingGate.cjs");
+const { createRelayMeshEnvelopeHandler } = require("./relayMeshEnvelopes.cjs");
+const { createRelayPeerLifecycle, isUnavailablePeerError } = require("./relayPeerLifecycle.cjs");
+const { createRelayPeerSignalRouter } = require("./relayPeerSignals.cjs");
+const { createRelayStatus } = require("./relayStatus.cjs");
+const { validateRelayHints } = require("./wireValidation/index.cjs");
+const { createConnectionCleanup } = require("./relay/connectionCleanup.cjs");
+const { createConnectionDataHandler } = require("./relay/connectionDispatcher.cjs");
+const { startRelayPeers } = require("./relay/peerStartup.cjs");
+const { createRelayEventStore } = require("./relay/nostrRelay.cjs");
+const { createMatterhornRuntimeEventBridge } = require("./relay/matterhornRuntimeEventBridge.cjs");
+const { createRelayOptionsFromArgs, createRelayRuntimeConfig, defaultStoragePath, parseArgs, resolveStoragePath } = require("./relay/config.cjs");
+const { startLocalPeerServer } = require("./localPeerServer.cjs");
+const { signRelayControl } = require("./relayIdentity.cjs");
+const { createRelayRoomRuntimePersistence, loadRelayRoomRuntimeSnapshot } = require("./relayRoomRuntimePersistence.cjs");
+
+function allowTimerExit(timer) {
+  if (typeof timer?.unref === "function") timer.unref();
+}
+
+function createMatterhornRelay(options = {}) {
+  const config = createRelayRuntimeConfig(options);
+
+  const startedAt = Date.now();
+  let relayPluginRuntimes;
+  let relayClientRouting;
+  let matterhornRuntimeEvents;
+  let encryptedRoomRuntimes;
+  const { relay, storage } = createRelayEventStore(config, {
+    ...options,
+    onEvent: (event, context) => matterhornRuntimeEvents?.handleMatterhornOperationEvent(event, context)
+  });
+  const pushStorage = createPushStorage(storage.db);
+  const pushEgress = createPushEgress({
+    pushStorage,
+    subject: config.pushSubject || "mailto:admin@matterhorn.gg"
+  });
+  const wss = new WebSocket.WebSocketServer({
+    noServer: true,
+    maxPayload: Math.max(
+      config.maxHostIpcMessageBytes,
+      config.maxMeshMessageBytes,
+      config.maxNostrMessageBytes,
+      config.maxRoomMessageBytes,
+      config.maxCallSignalBytes
+    )
+  });
+  const clientConnections = new Map();
+  const clientRooms = new Map();
+  const hostConnections = new Map();
+  const roomStores = new Map();
+  const relayChunkAssemblers = new WeakMap();
+  let roomPeer;
+  let relayPeer;
+  let closePromise;
+  let closing = false;
+  const relayDialPeers = new Map();
+
+  const sfu = createRelaySfu({
+    enabled: config.sfuEnabled,
+    peerId: config.sfuPeerId,
+    peerAddress: config.sfuPeerAddress,
+    maxParticipants: config.sfuMaxParticipants,
+    iceServers: config.iceServers,
+    createPeer: config.createPeer,
+    getGuest: sfuGuest,
+    roomSecretForRoom: (roomName) => roomStores.get(roomName)?.roomSecret || config.roomSecret,
+    onStatus: (roomName) => relayClientRouting?.broadcastSfuStatus(roomName),
+    logger: console
+  });
+
+  function debugRelay(message) {
+    if (process.env.MATTERHORN_DEBUG === "1") console.log(`matterhorn relay debug: ${message}`);
+  }
+
+  function runtimeInputRoomName(input = {}) {
+    return input.roomName || input.room?.id || input.roomId;
+  }
+
+  function runtimeInputAppPackId(input = {}) {
+    return input.room?.appPack?.id || input.appPack?.id || input.installed?.roomAppPack?.id || input.installed?.appPack?.id;
+  }
+
+  function runtimeInputState(input = {}) {
+    if (input.state && typeof input.state === "object") return input.state;
+    if (input.snapshot?.state && typeof input.snapshot.state === "object") return input.snapshot.state;
+    if (input.snapshot && typeof input.snapshot === "object" && input.snapshot.schemaVersion) return input.snapshot;
+    return undefined;
+  }
+
+  function runtimeInputOperations(input = {}) {
+    if (Array.isArray(input.operations)) return input.operations;
+    if (Array.isArray(input.snapshot?.operations)) return input.snapshot.operations;
+    return [];
+  }
+
+  function persistedStateMatchesInput(state, input) {
+    if (!state || typeof state !== "object") return false;
+    const roomName = runtimeInputRoomName(input);
+    if (state.roomId !== roomName) return false;
+    const appPackId = runtimeInputAppPackId(input);
+    if (appPackId && state.appPack?.id !== appPackId) return false;
+    return true;
+  }
+
+  function prepareRelayRoomRuntimeInput(input = {}) {
+    const roomName = runtimeInputRoomName(input);
+    if (!roomName || !config.storagePath) return input;
+
+    const persisted = loadRelayRoomRuntimeSnapshot(config.storagePath, roomName);
+    const persistedState = persistedStateMatchesInput(persisted?.state, input) ? persisted.state : undefined;
+    const incomingState = runtimeInputState(input);
+    const usePersisted = Boolean(persistedState && (!incomingState || isNewerRoomState(persistedState, incomingState)));
+    const initialState = usePersisted ? persistedState : incomingState;
+    const initialOperations = usePersisted ? persisted.operations : runtimeInputOperations(input);
+    const persistence = createRelayRoomRuntimePersistence({
+      storagePath: config.storagePath,
+      roomName,
+      initialState,
+      initialOperations
+    });
+
+    const prepared = { ...input };
+    if (!prepared.store) prepared.store = persistence.store;
+    if (!prepared.operationLog) prepared.operationLog = persistence.operationLog;
+    if (usePersisted) {
+      prepared.state = initialState;
+      prepared.operations = initialOperations;
+    }
+    return prepared;
+  }
+
+  function peerJsSignalingKey(signaling) {
+    return `${signaling.secure ? "wss" : "ws"}://${signaling.host}:${signaling.port}${signaling.path}`;
+  }
+
+  function relayAddressSignaling(address) {
+    return peerJsOptionsFromAddress(address, config.peerJsSignaling);
+  }
+
+  async function peerForRelayAddress(address) {
+    const signaling = relayAddressSignaling(address);
+    if (!signaling) throw new Error(`Relay address has no PeerJS signaling endpoint: ${address}`);
+    const key = peerJsSignalingKey(signaling);
+    const localKey = peerJsSignalingKey(config.peerJsSignaling);
+    if (key === localKey) {
+      if (!relayPeer?.open) throw new Error("Local relay mesh PeerJS peer is not open");
+      return relayPeer;
+    }
+
+    const existing = relayDialPeers.get(key);
+    if (existing?.peer && !existing.peer.destroyed) {
+      if (existing.peer.open) return existing.peer;
+      return existing.openPromise.then(() => existing.peer);
+    }
+
+    const peer = await config.createPeer(undefined, config.iceServers, { signaling });
+    peer.MatterhornStableId = `relay-dial:${key}`;
+    peer.on("error", (error) => {
+      peerLifecycle.handlePeerError(peer, `matterhorn relay dial peer ${key}`, error);
+    });
+    peer.on("disconnected", () => {
+      peerLifecycle.reconnectPeer(peer, `matterhorn relay dial peer ${key}`, "disconnected event");
+    });
+    const openPromise = waitForPeerOpen(peer, `matterhorn relay dial peer ${key}`);
+    relayDialPeers.set(key, { peer, openPromise });
+    await openPromise;
+    return peer;
+  }
+
+  function connectRelayAddress(address, dialOptions) {
+    const signaling = relayAddressSignaling(address);
+    if (signaling && peerJsSignalingKey(signaling) === peerJsSignalingKey(config.peerJsSignaling)) {
+      if (!relayPeer?.open) return undefined;
+      return relayPeer.connect(dialOptions.peerId, dialOptions.options);
+    }
+    return peerForRelayAddress(address).then((peer) => peer.connect(dialOptions.peerId, dialOptions.options));
+  }
+
+  let relayStatus;
+  let peerLifecycle;
+  const mesh = createRelayMeshRouter({
+    relayAddress: config.relayAddress,
+    relayMeshPeerId: config.relayMeshPeerId,
+    relayPeers: config.relayPeers,
+    defaultSignaling: config.peerJsSignaling,
+    activeRelayFanout: config.activeRelayFanout,
+    heartbeatMs: config.relayHeartbeatMs,
+    heartbeatTimeoutMs: config.relayHeartbeatTimeoutMs,
+    heartbeatFailoverMs: config.relayFailoverMs,
+    getRelayPeer: () => relayPeer,
+    connectRelayAddress,
+    attachConnection: (conn) => attachConnection(conn, { relayPeer: true }),
+    isUnavailablePeerError,
+    markRelayConnection: (conn) => relay.markRelayConnection(conn),
+    relayStatusMessage: (requestId, statusOptions) => relayStatus.relayStatusMessage(requestId, statusOptions),
+    debug: debugRelay
+  });
+
+  relayPluginRuntimes = createRelayPluginRuntimeManager({
+    relayAddress: config.relayAddress,
+    logger: console,
+    authenticateActor: options.authenticateActor,
+    sendRelayEnvelope: (message) => mesh.sendEnvelope(message)
+  });
+
+  encryptedRoomRuntimes = createEncryptedRoomRuntimeManager({
+    logger: console,
+    maxEventsPerStream: config.maxEventsPerStream
+  });
+  // Rebuild encrypted-room per-stream indexes from persisted v2 events on startup.
+  // This requires no room secrets; only plaintext v2 header tags are inspected.
+  try {
+    const rebuilt = encryptedRoomRuntimes.rebuildFromEvents((filters) => relay.query(filters));
+    if (rebuilt.inserted > 0) {
+      debugRelay(`rebuilt encrypted room indexes: ${rebuilt.operationEvents || 0} v2 events, ${rebuilt.ngramIndexEvents || 0} ngram index events`);
+    }
+  } catch {
+    // Relay may not be fully ready yet; events will be indexed as they arrive.
+  }
+
+  matterhornRuntimeEvents = createMatterhornRuntimeEventBridge({
+    debug: debugRelay,
+    encryptedRoomRuntimes,
+    operationEventIdentity: options.operationEventIdentity,
+    relay: () => relay,
+    relayClientRouting: () => relayClientRouting,
+    relayPluginRuntimes: () => relayPluginRuntimes,
+    roomStores: () => roomStores,
+    startedAt
+  });
+  let relayHostMessages;
+  const peerReconnects = createPeerReconnectTracker({
+    debug: debugRelay,
+    warn: (message) => console.warn(message)
+  });
+  peerLifecycle = createRelayPeerLifecycle({
+    debug: debugRelay,
+    isClosing: () => closing,
+    mesh,
+    peerReconnects,
+    relayPeer: () => relayPeer
+  });
+  const hostAuth = createRelayHostAuth(config.ipcSecret);
+  const incomingGate = createRelayIncomingGate(config);
+  const peerSignals = createRelayPeerSignalRouter({
+    config,
+    clientConnections,
+    mesh,
+    sfu
+  });
+  relayClientRouting = createRelayClientRouting({
+    clientConnections,
+    clientRooms,
+    config,
+    debug: debugRelay,
+    hostConnections,
+    isClosing: () => closing,
+    mesh,
+    peerSignals,
+    publishMatterhornOperation: matterhornRuntimeEvents.publishMatterhornOperation,
+    relayPluginRuntimes,
+    encryptedRoomRuntimes,
+    sfu,
+    pushStorage,
+    pushEgress,
+    eventStorage: storage
+  });
+  relayHostMessages = createRelayHostMessageHandler({
+    config,
+    relayPluginRuntimes,
+    hostConnections,
+    clientConnections,
+    mesh,
+    roomStores,
+    sendToClient: relayClientRouting.sendToClient,
+    catchUpMatterhornRuntime: matterhornRuntimeEvents.catchUpMatterhornRuntime,
+    prepareRoomRuntimeInput: prepareRelayRoomRuntimeInput
+  });
+  relayStatus = createRelayStatus({
+    config,
+    startedAt,
+    storage,
+    mesh,
+    relay,
+    sfu,
+    peerReconnects,
+    clientConnections,
+    hostConnections,
+    roomPeer: () => roomPeer,
+    relayPeer: () => relayPeer
+  });
+  const relayMeshEnvelopes = createRelayMeshEnvelopeHandler({
+    clientConnections,
+    clientRooms,
+    hostConnections,
+    mesh,
+    peerSignals,
+    relayPluginRuntimes,
+    encryptedRoomRuntimes,
+    relayStatus,
+    broadcastToRoom: relayClientRouting.broadcastToRoom,
+    rememberPersonalStateFromHostMessage: relayClientRouting.rememberPersonalStateFromHostMessage,
+    personalStateHostMessageForRoom: relayClientRouting.personalStateHostMessageForRoom,
+    pushStorage,
+    pushEgress,
+    eventStorage: storage,
+    config
+  });
+  async function retryPendingPushes() {
+    if (closing || !pushStorage?.selectPendingPushes) return;
+    pushStorage.pruneExpiredPendingPushes?.();
+    for (const pending of pushStorage.selectPendingPushes(100)) {
+      const relayPush = pending.payload;
+      const userId = relayPush?.target?.userId || pending.userId;
+      if (!relayPush || !userId) {
+        pushStorage.deletePendingPush?.(pending.pushId);
+        continue;
+      }
+      pushStorage.incrementPendingPushAttempts?.(pending.pushId);
+      const grant = pushStorage.selectGrant(userId);
+      if (grant) {
+        try {
+          const result = await pushEgress.sendRelayPush(relayPush);
+          if (result?.delivered > 0) pushStorage.deletePendingPush?.(pending.pushId);
+        } catch (err) {
+          if (process.env.MATTERHORN_DEBUG === "1") console.error(`Failed to retry pending push ${pending.pushId}:`, err);
+        }
+        continue;
+      }
+      mesh.sendEnvelope(relayPush);
+    }
+  }
+  const pendingPushSweep = setInterval(() => {
+    void retryPendingPushes();
+  }, 30_000);
+  allowTimerExit(pendingPushSweep);
+  const handleConnectionData = createConnectionDataHandler({
+    hostAuth,
+    isNostrMessage,
+    isRelayEnvelopeMessage,
+    mesh,
+    promoteRelayConnection,
+    relayClientRouting,
+    relayHostMessages,
+    relayMeshEnvelopes,
+    relayStatus,
+    relayTrust: config.relayTrustStore,
+    validateRelayHints
+  });
+  const cleanupConnection = createConnectionCleanup({
+    clientConnections,
+    clientRooms,
+    hostConnections,
+    incomingGate,
+    mesh,
+    relayClientRouting
+  });
+
+  const server = createRelayHttpServer({
+    wss,
+    allowedWebSocketPaths: ["/room", "/nostr"],
+    relayInformation: () => createRelayInformation({
+      name: "matterhorn peer relay",
+      description: "Nostr relay bridge for matterhorn PeerJS data channels.",
+      maxMessageLength: config.maxEventBytes,
+      maxEvents: config.maxEvents
+    }),
+    health: () => relayStatus.healthDocument()
+  });
+
+  wss.on("connection", (socket) => {
+    attachConnection(new WebSocketRelayConnection(socket, {
+      maxMessageBytes: config.maxHostIpcMessageBytes
+    }));
+  });
+
+  function findGuestForClient(runtimeState, clientId) {
+    for (const pluginState of Object.values(runtimeState?.plugins || {})) {
+      const guests = pluginState?.guests || {};
+      const guest = guestFromCollection(guests, clientId);
+      if (guest) return guest;
+    }
+    return undefined;
+  }
+
+  function guestFromCollection(guests, clientId) {
+    if (guests[clientId]) return guests[clientId];
+    return Object.values(guests).find((guest) => {
+      return guest?.callClientId === clientId || guest?.clientId === clientId || guest?.id === clientId || guest?.memberId === clientId;
+    });
+  }
+
+  async function sfuGuest(roomName, clientId) {
+    const runtime = relayPluginRuntimes?.get?.(roomName)?.runtime;
+    if (!runtime) return undefined;
+    return findGuestForClient(await runtime.getState(), clientId);
+  }
+
+  function relayDisconnectingMessage() {
+    const relayControl = signRelayControl(config.relayIdentity, {
+      type: "relay.disconnecting",
+      relayAddress: config.relayAddress,
+      roomPeerId: config.relayPeerId,
+      relayMeshPeerId: config.relayMeshPeerId
+    });
+    return {
+      type: "relay.disconnecting",
+      relayAddress: config.relayAddress,
+      roomPeerId: config.relayPeerId,
+      relayMeshPeerId: config.relayMeshPeerId,
+      relayClaim: config.relayClaim,
+      relayControl
+    };
+  }
+
+  function announceRelayDisconnecting() {
+    const message = relayDisconnectingMessage();
+    for (const conn of clientConnections.values()) sendMessage(conn, message);
+    for (const conn of mesh.connections()) sendMessage(conn, message);
+  }
+
+  function receiveRelayMessage(conn, message) {
+    if (!isRelayChunk(message)) return message;
+    let assembler = relayChunkAssemblers.get(conn);
+    if (!assembler) {
+      assembler = createRelayChunkAssembler({
+        maxBytes: Math.max(
+          config.maxHostIpcMessageBytes,
+          config.maxMeshMessageBytes,
+          config.maxNostrMessageBytes,
+          config.maxRoomMessageBytes,
+          config.maxCallSignalBytes
+        )
+      });
+      relayChunkAssemblers.set(conn, assembler);
+    }
+    return assembler.accept(message);
+  }
+
+  function closePeerConnections() {
+    const connections = new Set([
+      ...clientConnections.values(),
+      ...mesh.connections()
+    ]);
+    for (const conn of connections) conn.close?.();
+  }
+
+  function attachConnection(conn, options = {}) {
+    const relayPeerConnection = Boolean(options.relayPeer || mesh.connectionHasRelayMetadata(conn));
+    conn.on("data", (message) => {
+      if (!incomingGate.accept(conn, message)) return;
+      const receivedMessage = receiveRelayMessage(conn, message);
+      if (!receivedMessage) return;
+      if (receivedMessage !== message && !incomingGate.accept(conn, receivedMessage)) return;
+      if (isNostrMessage(receivedMessage)) {
+        if (!mesh.hasRelayConnection(conn) && mesh.connectionHasRelayMetadata(conn) && conn.MatterhornRelayAddress) promoteRelayConnection(conn);
+        relay.handleMessage(conn, receivedMessage);
+        return;
+      }
+      handleConnectionData(conn, receivedMessage);
+    });
+    relay.attachConnection(conn, { relayPeer: false, skipData: true });
+    conn.on("close", () => {
+      cleanupConnection(conn);
+    });
+    conn.on("error", () => {
+      if (conn.open === false) cleanupConnection(conn);
+    });
+
+    function sendRelayStatusHandshake() {
+      if (conn.MatterhornRelayHandshakeSent) return;
+      conn.MatterhornRelayHandshakeSent = true;
+      sendMessage(conn, relayStatus.relayStatusMessage(undefined, { includeKnownRelays: false }));
+    }
+
+    if (!relayPeerConnection) return;
+    if (conn.open === false) {
+      conn.on("open", sendRelayStatusHandshake);
+      return;
+    }
+    sendRelayStatusHandshake();
+  }
+
+  function promoteRelayConnection(conn) {
+    const promoted = mesh.promoteConnection(conn);
+    return promoted;
+  }
+
+  async function startPeer() {
+    const peers = await startRelayPeers({
+      attachConnection,
+      config,
+      debugRelay,
+      mesh,
+      peerLifecycle,
+      peerReconnects,
+      sfu
+    });
+    if (peers.roomPeer) roomPeer = peers.roomPeer;
+    if (peers.relayPeer) relayPeer = peers.relayPeer;
+  }
+
+  return {
+    config,
+    encryptedRoomRuntimes,
+    relay,
+    relayPluginRuntimes,
+    async registerRoom(input = {}) {
+      const prepared = prepareRelayRoomRuntimeInput(input);
+      const result = await relayPluginRuntimes.enableRoomComposition(prepared);
+      const roomName = runtimeInputRoomName(prepared);
+      if (roomName) await matterhornRuntimeEvents.catchUpMatterhornRuntime(roomName);
+      return result;
+    },
+    server,
+    wss,
+    attachConnection,
+    async listen() {
+      await startPeer();
+      return new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(config.ipcPort, config.ipcHost, () => {
+          server.off("error", reject);
+          const address = server.address();
+          if (address && typeof address === "object") config.ipcPort = address.port;
+          resolve(address);
+        });
+      });
+    },
+    async close() {
+      if (closePromise) return closePromise;
+      closePromise = (async () => {
+      closing = true;
+      await Promise.resolve();
+      announceRelayDisconnecting();
+      clearInterval(pendingPushSweep);
+      closePeerConnections();
+      const peerToDestroy = roomPeer;
+      const relayPeerToDestroy = relayPeer;
+      const dialPeersToDestroy = Array.from(relayDialPeers.values()).map((entry) => entry.peer);
+      relayDialPeers.clear();
+      roomPeer = undefined;
+      relayPeer = undefined;
+      sfu.close();
+      mesh.close();
+      await new Promise((resolve) => {
+        for (const socket of wss.clients) socket.close();
+        wss.close(() => {
+          if (!server.listening) {
+            resolve();
+            return;
+          }
+          server.close(() => resolve());
+        });
+      });
+      storage.close?.();
+      pushStorage?.close?.();
+      setTimeout(() => {
+        try {
+          peerToDestroy?.destroy();
+        } catch {}
+        try {
+          relayPeerToDestroy?.destroy();
+        } catch {}
+        for (const peer of dialPeersToDestroy) {
+          try {
+            peer?.destroy?.();
+          } catch {}
+        }
+      }, 0);
+      })();
+      return closePromise;
+    },
+    crash() {
+      setTimeout(() => {
+        void this.close();
+      }, 0);
+    }
+  };
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const options = createRelayOptionsFromArgs(args);
+  let localPeerServer;
+  if (options.localPeerjs) {
+    localPeerServer = await startLocalPeerServer(options.localPeerjs === true ? {} : options.localPeerjs);
+    options.peerJsSignaling = {
+      host: localPeerServer.host,
+      port: localPeerServer.port,
+      path: localPeerServer.path,
+      secure: localPeerServer.secure
+    };
+  }
+  const relay = createMatterhornRelay(options);
+  await relay.listen();
+  console.log("matterhorn relay IPC is live.");
+  console.log(`IPC:        ws://${relay.config.ipcHost}:${relay.config.ipcPort}/room`);
+  console.log(`Room peer:  ${relay.config.relayPeerId}`);
+  console.log(`Mesh peer:  ${relay.config.relayMeshPeerId}`);
+  console.log(`Mesh addr:  ${relay.config.relayAddress}`);
+  if (relay.config.relayIdentity?.logicalName) console.log(`Name:       ${relay.config.relayIdentity.logicalName}`);
+  if (relay.config.relayIdentity?.publicKeyFingerprint) console.log(`Identity:   ${relay.config.relayIdentity.publicKeyFingerprint}`);
+  if (relay.config.lastRelayTransportRotationReason) console.log(`Rotated:    ${relay.config.lastRelayTransportRotationReason}`);
+  if (relay.config.sfuEnabled) console.log(`SFU peer:   ${relay.config.sfuPeerId}`);
+  if (localPeerServer) console.log(`PeerJS:     ${localPeerServer.url}`);
+  console.log(`Storage:    ${relay.config.storagePath}`);
+}
+
+if (require.main === module) {
+  main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  WebSocketRelayConnection,
+  createMatterhornRelay,
+  defaultStoragePath,
+  parseArgs,
+  resolveStoragePath
+};