freertc 0.1.1 → 0.1.3

package/bin/freertc.mjs

@@ -34,7 +34,7 @@ Examples:
 
 function runInProject(command, args, { bootstrap = false } = {}) {
   if (bootstrap) {
-    ensureProjectFiles(PROJECT_ROOT);
+    ensureProjectFiles(PROJECT_ROOT, { updateExisting: true });
   }
 
   const result = spawnSync(command, args, {
@@ -87,7 +87,7 @@ if (subcommand === 'init' || subcommand === 'install') {
 }
 
 if (subcommand === 'deploy') {
-  ensureProjectFiles(PROJECT_ROOT);
+  ensureProjectFiles(PROJECT_ROOT, { updateExisting: true });
   requireWranglerConfig();
   const wrangler = resolveWranglerCommand(PROJECT_ROOT);
   runInProject(wrangler.command, [...wrangler.baseArgs, 'deploy', '--env', 'production', ...rest]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freertc",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Cloudflare Worker signaling relay for WebRTC peers with D1 storage.",
   "keywords": [
     "webrtc",

package/scripts/project-bootstrap.mjs

@@ -59,28 +59,42 @@ export function resolveProjectRoot(startDir = process.cwd()) {
   );
 }
 
-export function ensureProjectFiles(projectRoot) {
+function filesMatch(sourcePath, targetPath) {
+  if (!fs.existsSync(sourcePath) || !fs.existsSync(targetPath)) {
+    return false;
+  }
+
+  const source = fs.readFileSync(sourcePath);
+  const target = fs.readFileSync(targetPath);
+  return source.equals(target);
+}
+
+export function ensureProjectFiles(projectRoot, { updateExisting = false } = {}) {
   const targetRoot = path.resolve(projectRoot);
   if (targetRoot === PACKAGE_ROOT) {
     return [];
   }
 
-  const copied = [];
+  const synced = [];
 
   for (const [sourceRelativePath, targetRelativePath] of PROJECT_FILE_MAPPINGS) {
     const sourcePath = path.join(PACKAGE_ROOT, sourceRelativePath);
     const targetPath = path.join(targetRoot, targetRelativePath);
 
-    if (fs.existsSync(targetPath) || !fs.existsSync(sourcePath)) {
+    if (!fs.existsSync(sourcePath)) {
+      continue;
+    }
+
+    if (fs.existsSync(targetPath) && (!updateExisting || filesMatch(sourcePath, targetPath))) {
       continue;
     }
 
     fs.mkdirSync(path.dirname(targetPath), { recursive: true });
     fs.copyFileSync(sourcePath, targetPath);
-    copied.push(targetRelativePath);
+    synced.push(targetRelativePath);
   }
 
-  return copied;
+  return synced;
 }
 
 export function resolveWranglerCommand(cwd = process.cwd()) {

package/scripts/wrangler-install-wizard.mjs

@@ -402,7 +402,7 @@ async function main() {
   const forcedMode = modeFromArgs(process.argv);
 
   try {
-    const copiedFiles = ensureProjectFiles(ROOT);
+    const copiedFiles = ensureProjectFiles(ROOT, { updateExisting: true });
 
     console.log(`\n${PROJECT_NAME} Wrangler Install Wizard\n`);
     console.log(`Using project root: ${ROOT}`);
@@ -416,7 +416,7 @@ async function main() {
     }
 
     if (copiedFiles.length > 0) {
-      console.log('Copied package files into this project:');
+      console.log('Synced package-managed files into this project:');
       for (const file of copiedFiles) {
         console.log(`  - ${file}`);
       }
@@ -447,7 +447,7 @@ async function main() {
     if (copiedFiles.length === 0) {
       console.log('Required worker files already exist in this project.');
     } else {
-      console.log('Project bootstrapped from the published freertc package.');
+      console.log('Project files refreshed from the published freertc package.');
     }
 
     resolveWrangler();

package/src/index.js

@@ -227,15 +227,29 @@ async function forwardToRelay(relayUrl, message, selfRelayId) {
     const ws = resp.webSocket;
     ws.accept();
 
-    // Outbound Worker WebSocket: send immediately after accept(), no open event needed
-    const relayPeerId = selfRelayId || "relay-bridge";
-    ws.send(JSON.stringify({
-      psp_version: PSP_VERSION, type: "announce", network: message.network,
-      from: relayPeerId, message_id: crypto.randomUUID(),
-      timestamp: Date.now(), ttl_ms: 10_000, body: { capabilities: { relay: true } }
-    }));
-    ws.send(JSON.stringify(message));
-    ws.close();
+    await new Promise((resolve) => {
+      const relayPeerId = selfRelayId || "relay-bridge";
+      const closeTimer = setTimeout(() => {
+        try { ws.close(); } catch {}
+        resolve();
+      }, 250);
+
+      const finish = () => {
+        clearTimeout(closeTimer);
+        resolve();
+      };
+
+      ws.addEventListener("error", finish, { once: true });
+      ws.addEventListener("close", finish, { once: true });
+
+      // Outbound Worker WebSocket: send immediately after accept(), no open event needed.
+      ws.send(JSON.stringify({
+        psp_version: PSP_VERSION, type: "announce", network: message.network,
+        from: relayPeerId, message_id: crypto.randomUUID(),
+        timestamp: Date.now(), ttl_ms: 10_000, body: { capabilities: { relay: true } }
+      }));
+      ws.send(JSON.stringify(message));
+    });
   } catch {}
 }
 
@@ -260,6 +274,41 @@ async function listRelays(db) {
   return (result.results || []).map(r => ({ url: r.url, name: r.name }));
 }
 
+function mergeDiscoveredPeers(...peerGroups) {
+  const merged = new Map();
+
+  for (const peers of peerGroups) {
+    if (!Array.isArray(peers)) continue;
+    for (const peer of peers) {
+      const peerId = peer?.peer_id;
+      if (typeof peerId !== "string" || !peerId) continue;
+
+      const existing = merged.get(peerId);
+      const nextTimestamp = Number(peer?.timestamp || 0);
+      const existingTimestamp = Number(existing?.timestamp || 0);
+      if (!existing || nextTimestamp >= existingTimestamp) {
+        merged.set(peerId, peer);
+      }
+    }
+  }
+
+  return Array.from(merged.values()).sort((left, right) => left.peer_id.localeCompare(right.peer_id));
+}
+
+function sendPeerList(socket, network, peers, to = null, from = "bootstrap-relay") {
+  socket.send(JSON.stringify({
+    psp_version: PSP_VERSION,
+    type: "peer_list",
+    network,
+    from,
+    to,
+    message_id: crypto.randomUUID(),
+    timestamp: Date.now(),
+    ttl_ms: DEFAULT_TTL_MS,
+    body: { peers }
+  }));
+}
+
 // Broadcast peer list to all connected peers in a network
 async function broadcastPeerList(db, network) {
   const sockets = networkSubscribers.get(network);
@@ -279,23 +328,9 @@ async function broadcastPeerList(db, network) {
     session_id: row.session_id,
     timestamp: row.updated_at_ms
   }));
-
-  const message = {
-    psp_version: PSP_VERSION,
-    type: "peer_list",
-    network,
-    from: "bootstrap-relay",
-    to: null,
-    message_id: crypto.randomUUID(),
-    timestamp: Date.now(),
-    ttl_ms: DEFAULT_TTL_MS,
-    body: { peers }
-  };
-
-  const payload = JSON.stringify(message);
   for (const socket of sockets) {
     try {
-      socket.send(payload);
+      sendPeerList(socket, network, peers);
     } catch (e) {
       sockets.delete(socket);
     }
@@ -566,36 +601,36 @@ async function handleClientMessage(socket, rawData, env, ctx, prevPeerKey = null
       }
 
     } else if (type === "discover") {
-      // Local peers first
+      let localPeers = [];
       if (db) {
-        broadcastPeerList(db, network).catch(() => {});
+        localPeers = await findPeers(db, network, peerId);
       }
-      // Fan out to all known peer relays, exchanging relay lists bidirectionally
+
+      let remotePeers = [];
       if (env.RELAY_URL && env.DB) {
-        ctx.waitUntil((async () => {
-          const selfRelayId = env.RELAY_PEER_ID || "relay-bridge";
-          const selfUrl = normalizeRelayUrl(env.RELAY_URL);
-          const allRelays = await listRelays(env.DB);
-          const remoteUrls = allRelays.map(r => r.url).filter(u => u !== selfUrl);
-          if (!remoteUrls.length) return;
+        const selfRelayId = env.RELAY_PEER_ID || "relay-bridge";
+        const selfUrl = normalizeRelayUrl(env.RELAY_URL);
+        const allRelays = await listRelays(env.DB);
+        const remoteUrls = allRelays.map(r => r.url).filter(u => u !== selfUrl);
 
+        if (remoteUrls.length) {
           const results = await Promise.all(
             remoteUrls.map(u => queryRelayForPeers(u, network, selfRelayId, env.DB, allRelays))
           );
-          const remotePeers = results.flat();
-          if (!remotePeers.length) return;
-
-          const message = {
-            psp_version: PSP_VERSION, type: "peer_list", network,
-            from: selfRelayId, to: peerId,
-            message_id: crypto.randomUUID(), timestamp: Date.now(),
-            ttl_ms: DEFAULT_TTL_MS,
-            body: { peers: remotePeers }
-          };
-          try { socket.send(JSON.stringify(message)); } catch {}
-        })());
+          remotePeers = results.flat();
+        }
       }
 
+      try {
+        sendPeerList(
+          socket,
+          network,
+          mergeDiscoveredPeers(localPeers, remotePeers).filter(peer => peer.peer_id !== peerId),
+          peerId,
+          env.RELAY_PEER_ID || "bootstrap-relay"
+        );
+      } catch {}
+
     } else if (type === "ext" && message.body?.action === "relay_list") {
       // Remote relay is sharing its known relay list — cache any new entries
       if (db) {