javascript-solid-server 0.0.112 → 0.0.114

package/README.md

@@ -107,12 +107,12 @@ Full options: [docs/configuration.md](docs/configuration.md)
 
 ## Comparison
 
-| Server | Size | Deps | Notes |
-|--------|------|------|-------|
-| [JSS](https://github.com/JavaScriptSolidServer/JavaScriptSolidServer) | ~18K LoC | 15 | Minimal, JSON-LD native |
-| [NSS](https://github.com/nodeSolidServer/node-solid-server) | ~25K LoC | 58 | Original Solid server |
-| [CSS](https://github.com/CommunitySolidServer/CommunitySolidServer) | ~65K LoC | 70 | Modular, configurable |
-| [Pivot](https://github.com/solid-contrib/pivot) | ~70K LoC | 70+ | Built on CSS |
+| Server | Package | Packages | node_modules |
+|--------|---------|----------|-------------|
+| [JSS](https://github.com/JavaScriptSolidServer/JavaScriptSolidServer) | ~1 MB | ~191 | ~77 MB |
+| [CSS](https://github.com/CommunitySolidServer/CommunitySolidServer) | ~6 MB | ~311 | ~152 MB |
+| [Pivot](https://github.com/solid-contrib/pivot) | ~6 MB | ~311+ | ~152 MB |
+| [NSS](https://github.com/nodeSolidServer/node-solid-server) | ~7 MB | ~670 | ~539 MB |
 
 ## Performance
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "javascript-solid-server",
-  "version": "0.0.112",
+  "version": "0.0.114",
   "description": "A minimal, fast Solid server",
   "main": "src/index.js",
   "type": "module",

package/src/webrtc/index.js

@@ -2,13 +2,18 @@
  * WebRTC Signaling Server Plugin
  *
  * Lightweight signaling server for WebRTC peer-to-peer connections.
- * Relays SDP offers/answers and ICE candidates between authenticated users.
- * The actual media/data flow directly between peers — JSS just introduces them.
+ * Supports two discovery modes:
+ *
+ * 1. Identity-based — connect to a specific peer by WebID
+ * 2. Content-addressed — find peers sharing the same resource hash
+ *
+ * Relays SDP offers/answers and ICE candidates between peers.
+ * The actual media/data flows directly between peers — JSS just introduces them.
  *
  * Usage: jss start --webrtc
  * Endpoint: wss://your.pod/.webrtc
  *
- * Protocol (JSON over WebSocket):
+ * Identity-based protocol (JSON over WebSocket):
  *   → { type: "offer",     to: "<webid>", sdp: "..." }
  *   → { type: "answer",    to: "<webid>", sdp: "..." }
  *   → { type: "candidate", to: "<webid>", candidate: {...} }
@@ -21,6 +26,14 @@
  *   ← { type: "peers",     you: "<webid>", peers: ["<webid>", ...] }
  *   ← { type: "peer-joined", webId: "<webid>" }
  *   ← { type: "peer-left",   webId: "<webid>" }
+ *
+ * Content-addressed protocol (JSON over WebSocket):
+ *   → { type: "announce",  resource: "<hash>", offers: [{ sdp: "...", offer_id: "..." }, ...] }
+ *   → { type: "answer",    resource: "<hash>", to: "<peer_id>", offer_id: "...", sdp: "..." }
+ *   → { type: "leave",     resource: "<hash>" }
+ *   ← { type: "offer",     resource: "<hash>", from: "<peer_id>", offer_id: "...", sdp: "..." }
+ *   ← { type: "answer",    resource: "<hash>", from: "<peer_id>", offer_id: "...", sdp: "..." }
+ *   ← { type: "resource-peers", resource: "<hash>", count: <n> }
  */
 
 import websocket from '@fastify/websocket';
@@ -28,6 +41,9 @@ import { getWebIdFromRequestAsync } from '../auth/token.js';
 
 const ALLOWED_TYPES = new Set(['offer', 'answer', 'candidate', 'hangup']);
 const MAX_MESSAGE_SIZE = 64 * 1024; // 64KB
+const MAX_OFFERS_PER_ANNOUNCE = 10;
+const MAX_RESOURCES_PER_PEER = 50;
+const RESOURCE_HASH_RE = /^[a-fA-F0-9]{8,128}$/;
 
 /**
  * Register WebRTC signaling routes on Fastify instance
@@ -39,9 +55,20 @@ const MAX_MESSAGE_SIZE = 64 * 1024; // 64KB
 export async function webrtcPlugin(fastify, options = {}) {
   const path = options.path || '/.webrtc';
 
-  // Instance-scoped peer state
+  // Instance-scoped peer state (identity-based)
   const peers = new Map();
 
+  // Instance-scoped resource state (content-addressed)
+  // Map<resourceHash, Map<peerId, socket>>
+  const resources = new Map();
+
+  // Track which resources each peer has joined
+  // Map<peerId, Set<resourceHash>>
+  const peerResources = new Map();
+
+  // Peer ID counter for content-addressed mode
+  let nextPeerId = 1;
+
   // Only register @fastify/websocket if not already registered
   if (!fastify.websocketServer) {
     await fastify.register(websocket);
@@ -53,6 +80,8 @@ export async function webrtcPlugin(fastify, options = {}) {
       socket.close();
     }
     peers.clear();
+    resources.clear();
+    peerResources.clear();
   });
 
   function broadcast(senderWebId, msg) {
@@ -64,10 +93,138 @@ export async function webrtcPlugin(fastify, options = {}) {
     }
   }
 
+  // --- Content-addressed helpers ---
+
+  function getResourcePeers(resourceHash) {
+    let group = resources.get(resourceHash);
+    if (!group) {
+      group = new Map();
+      resources.set(resourceHash, group);
+    }
+    return group;
+  }
+
+  function addPeerToResource(peerId, socket, resourceHash) {
+    const group = getResourcePeers(resourceHash);
+    group.set(peerId, socket);
+
+    let tracked = peerResources.get(peerId);
+    if (!tracked) {
+      tracked = new Set();
+      peerResources.set(peerId, tracked);
+    }
+    tracked.add(resourceHash);
+  }
+
+  function removePeerFromResource(peerId, resourceHash) {
+    const group = resources.get(resourceHash);
+    if (group) {
+      group.delete(peerId);
+      if (group.size === 0) resources.delete(resourceHash);
+    }
+    const tracked = peerResources.get(peerId);
+    if (tracked) {
+      tracked.delete(resourceHash);
+      if (tracked.size === 0) peerResources.delete(peerId);
+    }
+  }
+
+  function removePeerFromAllResources(peerId) {
+    const tracked = peerResources.get(peerId);
+    if (!tracked) return;
+    for (const hash of tracked) {
+      const group = resources.get(hash);
+      if (group) {
+        group.delete(peerId);
+        if (group.size === 0) resources.delete(hash);
+      }
+    }
+    peerResources.delete(peerId);
+  }
+
+  function handleAnnounce(socket, peerId, msg) {
+    const hash = msg.resource;
+    if (!hash || typeof hash !== 'string' || !RESOURCE_HASH_RE.test(hash)) {
+      socket.send(JSON.stringify({ type: 'error', message: 'Invalid resource hash' }));
+      return;
+    }
+
+    // Limit resources per peer
+    const tracked = peerResources.get(peerId);
+    if (tracked && tracked.size >= MAX_RESOURCES_PER_PEER && !tracked.has(hash)) {
+      socket.send(JSON.stringify({ type: 'error', message: 'Too many resources' }));
+      return;
+    }
+
+    const group = getResourcePeers(hash);
+    addPeerToResource(peerId, socket, hash);
+
+    // Relay offers to existing peers in the group
+    const offers = Array.isArray(msg.offers) ? msg.offers.slice(0, MAX_OFFERS_PER_ANNOUNCE) : [];
+    const existingPeers = [...group.entries()].filter(([id]) => id !== peerId);
+
+    for (let i = 0; i < offers.length && i < existingPeers.length; i++) {
+      const offer = offers[i];
+      const [targetId, targetSocket] = existingPeers[i];
+      if (targetSocket.readyState !== 1) continue;
+      if (typeof offer.sdp !== 'string') continue;
+
+      const relay = Object.create(null);
+      relay.type = 'offer';
+      relay.resource = hash;
+      relay.from = peerId;
+      relay.offer_id = typeof offer.offer_id === 'string' ? offer.offer_id : String(i);
+      relay.sdp = offer.sdp;
+      try { targetSocket.send(JSON.stringify(relay)); } catch { /* peer gone */ }
+    }
+
+    // Tell the announcer how many peers are in the group
+    socket.send(JSON.stringify({
+      type: 'resource-peers',
+      resource: hash,
+      count: group.size - 1
+    }));
+  }
+
+  function handleResourceAnswer(socket, peerId, msg) {
+    const hash = msg.resource;
+    if (!hash || typeof hash !== 'string') return;
+
+    const group = resources.get(hash);
+    if (!group) return;
+
+    const targetId = msg.to;
+    const targetSocket = group.get(targetId);
+    if (!targetSocket || targetSocket.readyState !== 1) {
+      socket.send(JSON.stringify({ type: 'error', message: 'Peer not in resource group' }));
+      return;
+    }
+
+    const relay = Object.create(null);
+    relay.type = 'answer';
+    relay.resource = hash;
+    relay.from = peerId;
+    if (typeof msg.offer_id === 'string') relay.offer_id = msg.offer_id;
+    if (typeof msg.sdp === 'string') relay.sdp = msg.sdp;
+    try { targetSocket.send(JSON.stringify(relay)); } catch { /* peer gone */ }
+  }
+
+  function handleLeave(socket, peerId, msg) {
+    const hash = msg.resource;
+    if (!hash || typeof hash !== 'string') return;
+    removePeerFromResource(peerId, hash);
+  }
+
+  // --- WebSocket handler ---
+
   fastify.get(path, { websocket: true }, async (connection, request) => {
     const socket = connection.socket;
 
-    // Authenticate the connection
+    // Authenticate the connection (support query param for browser WebSocket which can't set headers)
+    const queryToken = request.query?.token;
+    if (queryToken && !request.headers.authorization) {
+      request.headers.authorization = `Bearer ${queryToken}`;
+    }
     const { webId } = await getWebIdFromRequestAsync(request);
     if (!webId) {
       socket.send(JSON.stringify({ type: 'error', message: 'Authentication required' }));
@@ -75,10 +232,16 @@ export async function webrtcPlugin(fastify, options = {}) {
       return;
     }
 
+    // Assign a stable peer ID for content-addressed mode
+    const peerId = String(nextPeerId++);
+    socket._peerId = peerId;
+
     // Register this peer (close old connection if reconnecting)
     const existing = peers.get(webId);
     const isReconnect = !!existing;
     if (existing) {
+      // Clean up old connection's resource memberships
+      if (existing._peerId) removePeerFromAllResources(existing._peerId);
       peers.delete(webId);
       existing.close();
     }
@@ -89,6 +252,7 @@ export async function webrtcPlugin(fastify, options = {}) {
     socket.send(JSON.stringify({
       type: 'peers',
       you: webId,
+      peerId: peerId,
       peers: [...peers.keys()].filter(id => id !== webId)
     }));
 
@@ -113,8 +277,28 @@ export async function webrtcPlugin(fastify, options = {}) {
         return;
       }
 
-      if (!msg.to || !msg.type) {
-        socket.send(JSON.stringify({ type: 'error', message: 'Missing "to" or "type" field' }));
+      if (!msg.type) {
+        socket.send(JSON.stringify({ type: 'error', message: 'Missing "type" field' }));
+        return;
+      }
+
+      // Content-addressed messages
+      if (msg.type === 'announce') {
+        handleAnnounce(socket, peerId, msg);
+        return;
+      }
+      if (msg.type === 'answer' && msg.resource) {
+        handleResourceAnswer(socket, peerId, msg);
+        return;
+      }
+      if (msg.type === 'leave') {
+        handleLeave(socket, peerId, msg);
+        return;
+      }
+
+      // Identity-based messages require "to" field
+      if (!msg.to) {
+        socket.send(JSON.stringify({ type: 'error', message: 'Missing "to" field' }));
         return;
       }
 
@@ -144,6 +328,9 @@ export async function webrtcPlugin(fastify, options = {}) {
     });
 
     socket.on('close', () => {
+      // Clean up content-addressed resource memberships
+      removePeerFromAllResources(peerId);
+
       // Only remove if this socket is still the registered one (not replaced by reconnect)
       if (peers.get(webId) === socket) {
         peers.delete(webId);

package/test/webrtc.test.js

@@ -209,4 +209,158 @@ describe('WebRTC Signaling', () => {
       await new Promise(r => setTimeout(r, 50));
     });
   });
+
+  describe('Content-Addressed Peer Discovery', () => {
+    const RESOURCE_HASH = 'a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2';
+
+    it('should return peer count on announce', async () => {
+      const { ws: alice } = await connectAndWait('alice');
+
+      alice.send(JSON.stringify({
+        type: 'announce',
+        resource: RESOURCE_HASH,
+        offers: []
+      }));
+
+      const msg = await waitForMessage(alice, 'resource-peers');
+      assert.strictEqual(msg.resource, RESOURCE_HASH);
+      assert.strictEqual(msg.count, 0);
+
+      alice.close();
+      await new Promise(r => setTimeout(r, 50));
+    });
+
+    it('should relay offers between peers sharing a resource', async () => {
+      const { ws: alice, peerId: alicePeerId } = await connectAndWait('alice');
+
+      // Alice announces with no offers (first in group)
+      alice.send(JSON.stringify({
+        type: 'announce',
+        resource: RESOURCE_HASH,
+        offers: []
+      }));
+      await waitForMessage(alice, 'resource-peers');
+
+      // Bob announces with an offer — should be relayed to Alice
+      const offerPromise = waitForMessage(alice, 'offer');
+      const { ws: bob, peerId: bobPeerId } = await connectAndWait('bob');
+
+      bob.send(JSON.stringify({
+        type: 'announce',
+        resource: RESOURCE_HASH,
+        offers: [{ sdp: 'v=0\r\nbob-offer', offer_id: 'offer1' }]
+      }));
+
+      const offer = await offerPromise;
+      assert.strictEqual(offer.type, 'offer');
+      assert.strictEqual(offer.resource, RESOURCE_HASH);
+      assert.strictEqual(offer.from, bobPeerId);
+      assert.strictEqual(offer.offer_id, 'offer1');
+      assert.ok(offer.sdp.includes('bob-offer'));
+
+      // Alice answers Bob
+      const answerPromise = waitForMessage(bob, 'answer');
+      alice.send(JSON.stringify({
+        type: 'answer',
+        resource: RESOURCE_HASH,
+        to: bobPeerId,
+        offer_id: 'offer1',
+        sdp: 'v=0\r\nalice-answer'
+      }));
+
+      const answer = await answerPromise;
+      assert.strictEqual(answer.type, 'answer');
+      assert.strictEqual(answer.resource, RESOURCE_HASH);
+      assert.strictEqual(answer.from, alicePeerId);
+      assert.ok(answer.sdp.includes('alice-answer'));
+
+      alice.close();
+      bob.close();
+      await new Promise(r => setTimeout(r, 50));
+    });
+
+    it('should clean up resources on disconnect', async () => {
+      const { ws: alice } = await connectAndWait('alice');
+
+      alice.send(JSON.stringify({
+        type: 'announce',
+        resource: RESOURCE_HASH,
+        offers: []
+      }));
+      await waitForMessage(alice, 'resource-peers');
+
+      // Bob joins the resource group
+      const { ws: bob } = await connectAndWait('bob');
+      bob.send(JSON.stringify({
+        type: 'announce',
+        resource: RESOURCE_HASH,
+        offers: []
+      }));
+      const bobPeers = await waitForMessage(bob, 'resource-peers');
+      assert.strictEqual(bobPeers.count, 1); // alice is there
+
+      // Alice disconnects
+      alice.close();
+      await new Promise(r => setTimeout(r, 200));
+
+      // Charlie joins — should see only bob
+      const { ws: charlie } = await connectAndWait('bob'); // reuse bob pod
+      charlie.send(JSON.stringify({
+        type: 'announce',
+        resource: RESOURCE_HASH,
+        offers: []
+      }));
+      const charliePeers = await waitForMessage(charlie, 'resource-peers');
+      // bob was reconnected (old connection closed), so count depends on timing
+      assert.ok(charliePeers.count >= 0);
+
+      bob.close();
+      charlie.close();
+      await new Promise(r => setTimeout(r, 50));
+    });
+
+    it('should handle leave message', async () => {
+      const { ws: alice } = await connectAndWait('alice');
+
+      alice.send(JSON.stringify({
+        type: 'announce',
+        resource: RESOURCE_HASH,
+        offers: []
+      }));
+      await waitForMessage(alice, 'resource-peers');
+
+      // Leave the resource group
+      alice.send(JSON.stringify({ type: 'leave', resource: RESOURCE_HASH }));
+
+      // Bob joins — should see 0 peers (alice left)
+      const { ws: bob } = await connectAndWait('bob');
+      bob.send(JSON.stringify({
+        type: 'announce',
+        resource: RESOURCE_HASH,
+        offers: []
+      }));
+      const msg = await waitForMessage(bob, 'resource-peers');
+      assert.strictEqual(msg.count, 0);
+
+      alice.close();
+      bob.close();
+      await new Promise(r => setTimeout(r, 50));
+    });
+
+    it('should reject invalid resource hash', async () => {
+      const { ws: alice } = await connectAndWait('alice');
+
+      alice.send(JSON.stringify({
+        type: 'announce',
+        resource: 'not-a-hex-hash!',
+        offers: []
+      }));
+
+      const err = await waitForMessage(alice, 'error');
+      assert.ok(err.message.includes('Invalid resource hash'));
+
+      alice.close();
+      await new Promise(r => setTimeout(r, 50));
+    });
+  });
 });