@mh-gg/relay-runtime 0.1.1-alpha.20260613T085325975Z

package/src/encryptedRoomRuntimeManager.cjs

@@ -0,0 +1,131 @@
+const { createEncryptedRoomRuntime } = require("./encryptedRoomRuntime.cjs");
+
+const MATTERHORN_OPERATION_KIND = 9001;
+const MATTERHORN_INDEX_NGRAM_KIND = 9013;
+
+function tagValue(tags, name) {
+  if (!Array.isArray(tags)) return undefined;
+  const tag = tags.find((item) => Array.isArray(item) && item[0] === name && typeof item[1] === "string");
+  return tag?.[1];
+}
+
+function roomNameForEncryptedRuntimeEvent(event) {
+  const roomName = tagValue(event?.tags, "d") || tagValue(event?.tags, "room");
+  if (typeof roomName !== "string" || !roomName) return undefined;
+  if (event.kind === MATTERHORN_OPERATION_KIND && tagValue(event.tags, "scheme") !== "matterhorn.operation.v2") return undefined;
+  if (event.kind !== MATTERHORN_OPERATION_KIND && event.kind !== MATTERHORN_INDEX_NGRAM_KIND) return undefined;
+  return roomName;
+}
+
+function createEncryptedRoomRuntimeManager(options = {}) {
+  const logger = options.logger || { debug() {}, info() {}, warn() {}, error() {} };
+  const maxEventsPerStream = Number.isInteger(options.maxEventsPerStream) && options.maxEventsPerStream > 0
+    ? options.maxEventsPerStream
+    : 10000;
+  const runtimes = new Map(); // roomName -> EncryptedRoomRuntime
+
+  function ensureRoom(roomName) {
+    let runtime = runtimes.get(roomName);
+    if (!runtime) {
+      runtime = createEncryptedRoomRuntime({ roomName, logger, maxEventsPerStream });
+      runtimes.set(roomName, runtime);
+    }
+    return runtime;
+  }
+
+  function hasRoom(roomName) {
+    return runtimes.has(roomName);
+  }
+
+  function getRoom(roomName) {
+    return runtimes.get(roomName);
+  }
+
+  function removeRoom(roomName) {
+    return runtimes.delete(roomName);
+  }
+
+  function insertEvent(roomName, nostrEvent) {
+    const runtime = ensureRoom(roomName);
+    return runtime.insert(nostrEvent);
+  }
+
+  function searchNgrams(roomName, options = {}) {
+    const runtime = getRoom(roomName);
+    if (!runtime || typeof runtime.searchNgrams !== "function") {
+      return { events: [], matches: [], total: 0, queryTokenCount: 0 };
+    }
+    return runtime.searchNgrams(options);
+  }
+
+  function ngramIndexStats(roomName) {
+    const runtime = getRoom(roomName);
+    return runtime?.ngramIndexStats?.() || { targets: 0, indexEvents: 0, tokenPostingLists: 0, postings: 0 };
+  }
+
+  function listRooms() {
+    return Array.from(runtimes.keys()).sort();
+  }
+
+  function snapshot() {
+    const result = {};
+    for (const [roomName, runtime] of runtimes) {
+      result[roomName] = runtime.snapshot();
+    }
+    return result;
+  }
+
+  function restore(data) {
+    let inserted = 0;
+    let rooms = 0;
+    for (const [roomName, snap] of Object.entries(data || {})) {
+      const runtime = ensureRoom(roomName);
+      const result = runtime.restore(snap);
+      if (result.ok) {
+        rooms += 1;
+        inserted += result.inserted;
+      }
+    }
+    return { ok: true, rooms, inserted };
+  }
+
+  function rebuildFromEvents(queryEvents) {
+    let inserted = 0;
+    let operationEvents = 0;
+    let ngramIndexEvents = 0;
+    try {
+      const events = queryEvents([{ kinds: [MATTERHORN_OPERATION_KIND, MATTERHORN_INDEX_NGRAM_KIND] }]);
+      for (const event of events || []) {
+        const roomName = roomNameForEncryptedRuntimeEvent(event);
+        if (!roomName) continue;
+        const result = insertEvent(roomName, event);
+        if (result.ok && result.inserted) {
+          inserted += 1;
+          if (event.kind === MATTERHORN_OPERATION_KIND) operationEvents += 1;
+          else if (event.kind === MATTERHORN_INDEX_NGRAM_KIND) ngramIndexEvents += 1;
+        }
+      }
+    } catch (error) {
+      logger.warn?.("Encrypted room runtime rebuild failed", error);
+    }
+    return { ok: true, inserted, operationEvents, ngramIndexEvents };
+  }
+
+  return {
+    ensureRoom,
+    getRoom,
+    hasRoom,
+    insertEvent,
+    listRooms,
+    ngramIndexStats,
+    removeRoom,
+    restore,
+    searchNgrams,
+    snapshot,
+    rebuildFromEvents
+  };
+}
+
+module.exports = {
+  createEncryptedRoomRuntimeManager
+};

package/src/index.cjs

@@ -0,0 +1,152 @@
+const { ensureRoomSecurity } = require("@mh-gg/room-security");
+const { createEncryptedRoomRuntime } = require("./encryptedRoomRuntime.cjs");
+const { createEncryptedRoomRuntimeManager } = require("./encryptedRoomRuntimeManager.cjs");
+const { createRelayPluginRuntimeManager, isNewerRoomState } = require("./pluginRuntimeHost.cjs");
+
+const PEER_OPEN_TIMEOUT_MS = 15000;
+const PEER_RECONNECT_WARN_WINDOW_MS = 60000;
+const PEER_RECONNECT_WARN_THRESHOLD = 3;
+
+function jsonClone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+function isNewerStore(left, right) {
+  const leftVersion = Number(left?.state?.version || 0);
+  const rightVersion = Number(right?.state?.version || 0);
+  if (leftVersion !== rightVersion) return leftVersion > rightVersion;
+  const leftUpdatedAt = Number(left?.updatedAt || left?.state?.updatedAt || 0);
+  const rightUpdatedAt = Number(right?.updatedAt || right?.state?.updatedAt || 0);
+  return leftUpdatedAt > rightUpdatedAt;
+}
+
+function relayRoomStoreSnapshot(roomName, rawStore) {
+  if (!rawStore || typeof rawStore !== "object" || rawStore.roomName !== roomName) return undefined;
+  const snapshot = jsonClone(rawStore);
+  ensureRoomSecurity(snapshot);
+  return snapshot;
+}
+
+function removePeerListener(peer, event, callback) {
+  if (typeof peer.off === "function") {
+    peer.off(event, callback);
+    return;
+  }
+  if (typeof peer.removeListener === "function") peer.removeListener(event, callback);
+}
+
+function waitForPeerOpen(peer, label, timeoutMs = PEER_OPEN_TIMEOUT_MS) {
+  if (peer.open) return Promise.resolve(peer.id);
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      cleanup();
+      reject(new Error(`${label} did not open within ${timeoutMs}ms`));
+    }, timeoutMs);
+
+    function cleanup() {
+      clearTimeout(timer);
+      removePeerListener(peer, "open", onOpen);
+      removePeerListener(peer, "error", onError);
+    }
+
+    function onOpen(id) {
+      cleanup();
+      resolve(id);
+    }
+
+    function onError(error) {
+      cleanup();
+      reject(error);
+    }
+
+    peer.on("open", onOpen);
+    peer.on("error", onError);
+  });
+}
+
+function createPeerReconnectTracker(options = {}) {
+  const loggedPeerOpenIds = new Set();
+  const statsByKey = new Map();
+  const warnedLabels = new Set();
+  const windowMs = options.windowMs || PEER_RECONNECT_WARN_WINDOW_MS;
+  const threshold = options.threshold || PEER_RECONNECT_WARN_THRESHOLD;
+  const warn = options.warn || console.warn;
+  const debug = options.debug || (() => {});
+
+  function stablePeerId(peer) {
+    return peer?.MatterhornStableId || peer?.id || "unknown";
+  }
+
+  function logOpen(label, id, peer) {
+    if (peer) {
+      peer.MatterhornStableId ||= id;
+      peer.MatterhornLastReconnectAt = 0;
+    }
+    if (loggedPeerOpenIds.has(id)) {
+      debug(`${label} reopened as ${id}`);
+      return;
+    }
+    loggedPeerOpenIds.add(id);
+    console.log(`${label} is live as ${id}`);
+  }
+
+  function warnOnRepeatedReconnect(peer, label, reason) {
+    const now = Date.now();
+    const peerId = stablePeerId(peer);
+    const key = `${label}:${peerId}`;
+    let stats = statsByKey.get(key);
+    if (!stats || now - stats.windowStartedAt > windowMs) {
+      stats = {
+        label,
+        peerId,
+        windowStartedAt: now,
+        windowAttempts: 0,
+        totalAttempts: stats?.totalAttempts || 0,
+        lastAttemptAt: stats?.lastAttemptAt || 0
+      };
+    }
+
+    stats.windowAttempts += 1;
+    stats.totalAttempts += 1;
+    stats.lastAttemptAt = now;
+    statsByKey.set(key, stats);
+    debug(`${label} reconnect attempt ${stats.totalAttempts} for ${peerId} after ${reason}`);
+    if (warnedLabels.has(label) || stats.windowAttempts < threshold) return;
+
+    warnedLabels.add(label);
+    warn(
+      `${label} PeerJS signaling is unstable (${stats.windowAttempts} reconnect attempts in ${Math.round(windowMs / 1000)}s). ` +
+      "This is signaling churn, not guest-room reconnects; further reconnects are debug-only. Set MATTERHORN_DEBUG=1 for per-event details."
+    );
+  }
+
+  function summary() {
+    return Array.from(statsByKey.values()).map((stats) => ({
+      label: stats.label,
+      peerId: stats.peerId,
+      windowAttempts: stats.windowAttempts,
+      totalAttempts: stats.totalAttempts,
+      lastAttemptAt: stats.lastAttemptAt,
+      warned: warnedLabels.has(stats.label)
+    }));
+  }
+
+  return {
+    logOpen,
+    stablePeerId,
+    summary,
+    warn: warnOnRepeatedReconnect
+  };
+}
+
+module.exports = {
+  createEncryptedRoomRuntime,
+  createEncryptedRoomRuntimeManager,
+  createRelayPluginRuntimeManager,
+  createPeerReconnectTracker,
+  isNewerRoomState,
+  isNewerStore,
+  jsonClone,
+  relayRoomStoreSnapshot,
+  waitForPeerOpen
+};