uniwrtc 1.0.9 → 1.1.0

package/NOSTR_INTEGRATION.md

@@ -0,0 +1,6 @@
+# Nostr notes
+
+The demo page now defaults to Nostr (no UI toggle).
+
+- Nostr client: [src/nostr/nostrClient.js](src/nostr/nostrClient.js)
+- UI integration: [src/main.js](src/main.js)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uniwrtc",
-  "version": "1.0.9",
+  "version": "1.1.0",
   "description": "A universal WebRTC signaling service",
   "main": "server.js",
   "type": "module",
@@ -20,7 +20,9 @@
   ],
   "author": "",
   "license": "MIT",
-  "dependencies": {},
+  "dependencies": {
+    "nostr-tools": "^2.9.0"
+  },
   "devDependencies": {
     "@playwright/test": "^1.57.0",
     "vite": "^6.0.6"

package/src/main.js

@@ -1,9 +1,13 @@
 import './style.css';
 import UniWRTCClient from '../client-browser.js';
+import { createNostrClient } from './nostr/nostrClient.js';
 
 // Make UniWRTCClient available globally for backwards compatibility
 window.UniWRTCClient = UniWRTCClient;
 
+// Nostr is the default transport (no toggle)
+let nostrClient = null;
+
 let client = null;
 const peerConnections = new Map();
 const dataChannels = new Map();
@@ -20,8 +24,8 @@ document.getElementById('app').innerHTML = `
             <h2>Connection</h2>
             <div class="connection-controls">
                 <div>
-                    <label style="display: block; margin-bottom: 5px; color: #64748b; font-size: 13px;">Server URL</label>
-                    <input type="text" id="serverUrl" data-testid="serverUrl" placeholder="wss://signal.peer.ooo or ws://localhost:8080" value="wss://signal.peer.ooo">
+                    <label style="display: block; margin-bottom: 5px; color: #64748b; font-size: 13px;">Relay URL</label>
+                    <input type="text" id="relayUrl" placeholder="wss://relay.damus.io" value="wss://relay.damus.io" style="width: 100%; padding: 8px; border: 1px solid #e2e8f0; border-radius: 4px; font-family: monospace; font-size: 12px;">
                 </div>
                 <div>
                     <label style="display: block; margin-bottom: 5px; color: #64748b; font-size: 13px;">Room / Session ID</label>
@@ -147,6 +151,67 @@ function updatePeerList() {
 }
 
 window.connect = async function() {
+    await connectNostr();
+};
+
+async function connectNostr() {
+    const relayUrl = document.getElementById('relayUrl').value.trim();
+    const roomIdInput = document.getElementById('roomId');
+    const roomId = roomIdInput.value.trim();
+    
+    if (!relayUrl) {
+        log('Please enter a relay URL', 'error');
+        return;
+    }
+
+    const effectiveRoom = roomId || `room-${Math.random().toString(36).substring(2, 10)}`;
+    if (!roomId) roomIdInput.value = effectiveRoom;
+
+    try {
+        log(`Connecting to Nostr relay: ${relayUrl}...`, 'info');
+
+        if (nostrClient) {
+            await nostrClient.disconnect();
+            nostrClient = null;
+        }
+
+        nostrClient = createNostrClient({
+            relayUrl,
+            room: effectiveRoom,
+            onState: (state) => {
+                if (state === 'connected') updateStatus(true);
+                if (state === 'disconnected') updateStatus(false);
+            },
+            onMessage: ({ from, text }) => {
+                displayChatMessage(text, from, false);
+            },
+            onPeer: ({ peerId }) => {
+                // Use the existing peer list UI as a simple "seen peers" list
+                if (!peerConnections.has(peerId)) {
+                    peerConnections.set(peerId, null);
+                    updatePeerList();
+                    log(`Peer seen: ${peerId.substring(0, 6)}...`, 'success');
+                }
+            }
+        });
+
+        await nostrClient.connect();
+
+        const myPubkey = nostrClient.getPublicKey();
+        document.getElementById('clientId').textContent = myPubkey.substring(0, 16) + '...';
+        document.getElementById('sessionId').textContent = effectiveRoom;
+        log(`Joined Nostr room: ${effectiveRoom}`, 'success');
+        
+        updateStatus(true);
+
+        log('Nostr connection established', 'success');
+    } catch (error) {
+        log(`Nostr connection error: ${error.message}`, 'error');
+        updateStatus(false);
+    }
+}
+
+async function connectWebRTC() {
     const serverUrl = document.getElementById('serverUrl').value.trim();
     const roomId = document.getElementById('roomId').value.trim();
 
@@ -161,35 +226,35 @@ window.connect = async function() {
     }
 
     try {
-            log(`Connecting to ${serverUrl}...`, 'info');
+        log(`Connecting to ${serverUrl}...`, 'info');
         
         // For Cloudflare, use /ws endpoint with room ID query param
         let finalUrl = serverUrl;
         if (serverUrl.includes('signal.peer.ooo')) {
-                finalUrl = `${serverUrl.replace(/\/$/, '')}/ws?room=${roomId}`;
-                log(`Using Cloudflare Durable Objects with session: ${roomId}`, 'info');
+            finalUrl = `${serverUrl.replace(/\/$/, '')}/ws?room=${roomId}`;
+            log(`Using Cloudflare Durable Objects with session: ${roomId}`, 'info');
         }
         
         client = new UniWRTCClient(finalUrl, { autoReconnect: false });
         
         client.on('connected', (data) => {
-                log(`Connected with client ID: ${data.clientId}`, 'success');
+            log(`Connected with client ID: ${data.clientId}`, 'success');
             document.getElementById('clientId').textContent = data.clientId;
             updateStatus(true);
             
             // Auto-join the room
-                log(`Joining session: ${roomId}`, 'info');
+            log(`Joining session: ${roomId}`, 'info');
             client.joinSession(roomId);
         });
 
         client.on('joined', (data) => {
-                log(`Joined session: ${data.sessionId}`, 'success');
+            log(`Joined session: ${data.sessionId}`, 'success');
             document.getElementById('sessionId').textContent = data.sessionId;
             
             if (data.clients && data.clients.length > 0) {
-                    log(`Found ${data.clients.length} existing peers`, 'info');
+                log(`Found ${data.clients.length} existing peers`, 'info');
                 data.clients.forEach(peerId => {
-                        log(`Creating connection to existing peer: ${peerId.substring(0, 6)}...`, 'info');
+                    log(`Creating connection to existing peer: ${peerId.substring(0, 6)}...`, 'info');
                     createPeerConnection(peerId, true);
                 });
             }
@@ -198,11 +263,11 @@ window.connect = async function() {
         client.on('peer-joined', (data) => {
             // Only handle peers in our session
             if (client.sessionId && data.sessionId !== client.sessionId) {
-                    log(`Ignoring peer from different session: ${data.sessionId}`, 'warning');
+                log(`Ignoring peer from different session: ${data.sessionId}`, 'warning');
                 return;
             }
             
-                log(`Peer joined: ${data.peerId.substring(0, 6)}...`, 'success');
+            log(`Peer joined: ${data.peerId.substring(0, 6)}...`, 'success');
             
             // Wait a bit to ensure both peers are ready
             setTimeout(() => {
@@ -211,7 +276,7 @@ window.connect = async function() {
         });
 
         client.on('peer-left', (data) => {
-                log(`Peer left: ${data.peerId.substring(0, 6)}...`, 'warning');
+            log(`Peer left: ${data.peerId.substring(0, 6)}...`, 'warning');
             const pc = peerConnections.get(data.peerId);
             if (pc) {
                 pc.close();
@@ -222,17 +287,17 @@ window.connect = async function() {
         });
 
         client.on('offer', async (data) => {
-                log(`Received offer from ${data.peerId.substring(0, 6)}...`, 'info');
+            log(`Received offer from ${data.peerId.substring(0, 6)}...`, 'info');
             const pc = peerConnections.get(data.peerId) || await createPeerConnection(data.peerId, false);
             await pc.setRemoteDescription(new RTCSessionDescription(data.offer));
             const answer = await pc.createAnswer();
             await pc.setLocalDescription(answer);
             client.sendAnswer(answer, data.peerId);
-                log(`Sent answer to ${data.peerId.substring(0, 6)}...`, 'success');
+            log(`Sent answer to ${data.peerId.substring(0, 6)}...`, 'success');
         });
 
         client.on('answer', async (data) => {
-                log(`Received answer from ${data.peerId.substring(0, 6)}...`, 'info');
+            log(`Received answer from ${data.peerId.substring(0, 6)}...`, 'info');
             const pc = peerConnections.get(data.peerId);
             if (pc) {
                 await pc.setRemoteDescription(new RTCSessionDescription(data.answer));
@@ -240,7 +305,7 @@ window.connect = async function() {
         });
 
         client.on('ice-candidate', async (data) => {
-                log(`Received ICE candidate from ${data.peerId.substring(0, 6)}...`, 'info');
+            log(`Received ICE candidate from ${data.peerId.substring(0, 6)}...`, 'info');
             const pc = peerConnections.get(data.peerId);
             if (pc && data.candidate) {
                 await pc.addIceCandidate(new RTCIceCandidate(data.candidate));
@@ -257,17 +322,21 @@ window.connect = async function() {
         });
 
         client.on('error', (data) => {
-                log(`Error: ${data.message}`, 'error');
+            log(`Error: ${data.message}`, 'error');
         });
 
         await client.connect();
     } catch (error) {
-            log(`Connection error: ${error.message}`, 'error');
+        log(`Connection error: ${error.message}`, 'error');
         updateStatus(false);
     }
-};
+}
 
 window.disconnect = function() {
+    if (nostrClient) {
+        nostrClient.disconnect().catch(() => {});
+        nostrClient = null;
+    }
     if (client) {
         client.disconnect();
         client = null;
@@ -347,6 +416,15 @@ window.sendChatMessage = function() {
         return;
     }
 
+    if (nostrClient) {
+        nostrClient.sendMessage(message).catch((e) => {
+            log(`Failed to send via Nostr: ${e?.message || e}`, 'error');
+        });
+        displayChatMessage(message, 'You', true);
+        document.getElementById('chatMessage').value = '';
+        return;
+    }
+
     if (dataChannels.size === 0) {
         log('No peer connections available. Wait for data channels to open.', 'error');
         return;

package/src/nostr/nostrClient.js

@@ -0,0 +1,243 @@
+import { generateSecretKey, getPublicKey, finalizeEvent } from 'nostr-tools/pure';
+
+function bytesToHex(bytes) {
+  return Array.from(bytes)
+    .map((b) => b.toString(16).padStart(2, '0'))
+    .join('');
+}
+
+function isHex64(s) {
+  return typeof s === 'string' && /^[0-9a-fA-F]{64}$/.test(s);
+}
+
+/**
+ * Minimal Nostr relay client using raw WebSocket protocol.
+ * - Publishes kind:1 events tagged with ['t', room] and ['room', room]
+ * - Subscribes to kind:1 events filtered by #t
+ */
+export function createNostrClient({ relayUrl, room, onMessage, onPeer, onState } = {}) {
+  if (!relayUrl) throw new Error('relayUrl is required');
+  if (!room) throw new Error('room is required');
+
+  const state = {
+    relayUrl,
+    room,
+    ws: null,
+    subId: `sub-${room}-${Math.random().toString(36).slice(2, 8)}`,
+    secretKeyHex: null,
+    pubkey: null,
+    seen: new Set(),
+  };
+
+  function ensureKeys() {
+    if (state.pubkey && state.secretKeyHex) return;
+
+    let stored = localStorage.getItem('nostr-secret-key');
+    // If stored value looks like an array string from prior buggy storage, clear it
+    if (stored && stored.includes(',')) {
+      localStorage.removeItem('nostr-secret-key');
+      stored = null;
+    }
+
+    if (!isHex64(stored)) {
+      const secretBytes = generateSecretKey();
+      state.secretKeyHex = bytesToHex(secretBytes);
+      localStorage.setItem('nostr-secret-key', state.secretKeyHex);
+    } else {
+      state.secretKeyHex = stored;
+    }
+
+    state.pubkey = getPublicKey(state.secretKeyHex);
+  }
+
+  function getPublicKeyHex() {
+    ensureKeys();
+    return state.pubkey;
+  }
+
+  function setState(next) {
+    try {
+      onState?.(next);
+    } catch {
+      // ignore
+    }
+  }
+
+  function parseIncoming(event) {
+    let msg;
+    try {
+      msg = JSON.parse(event.data);
+    } catch {
+      return;
+    }
+
+    if (!Array.isArray(msg) || msg.length < 2) return;
+    const [type] = msg;
+
+    if (type === 'EVENT') {
+      const nostrEvent = msg[2];
+      if (!nostrEvent || typeof nostrEvent !== 'object') return;
+      if (nostrEvent.id && state.seen.has(nostrEvent.id)) return;
+      if (nostrEvent.id) state.seen.add(nostrEvent.id);
+
+      // Ensure it's for our room
+      const tags = Array.isArray(nostrEvent.tags) ? nostrEvent.tags : [];
+      const roomTag = tags.find((t) => Array.isArray(t) && t[0] === 'room');
+      if (!roomTag || roomTag[1] !== state.room) return;
+
+      // Content is JSON
+      let payload;
+      try {
+        payload = JSON.parse(nostrEvent.content);
+      } catch {
+        return;
+      }
+
+      if (payload?.type === 'peer-join' && payload.peerId) {
+        try {
+          onPeer?.({ peerId: payload.peerId });
+        } catch {
+          // ignore
+        }
+        return;
+      }
+
+      if (payload?.type === 'message' && typeof payload.message === 'string') {
+        const from = (payload.peerId || nostrEvent.pubkey || 'peer').substring(0, 8) + '...';
+        try {
+          onMessage?.({ from, text: payload.message });
+        } catch {
+          // ignore
+        }
+      }
+    }
+  }
+
+  function sendRaw(frame) {
+    if (!state.ws || state.ws.readyState !== WebSocket.OPEN) {
+      throw new Error('Relay not connected');
+    }
+    state.ws.send(JSON.stringify(frame));
+  }
+
+  async function connect() {
+    ensureKeys();
+
+    setState('connecting');
+
+    const ws = new WebSocket(state.relayUrl);
+    state.ws = ws;
+
+    await new Promise((resolve, reject) => {
+      const onOpen = () => {
+        cleanup();
+        resolve();
+      };
+      const onError = () => {
+        cleanup();
+        reject(new Error('Failed to connect to relay'));
+      };
+      const cleanup = () => {
+        ws.removeEventListener('open', onOpen);
+        ws.removeEventListener('error', onError);
+      };
+      ws.addEventListener('open', onOpen);
+      ws.addEventListener('error', onError);
+    });
+
+    ws.addEventListener('message', parseIncoming);
+    ws.addEventListener('close', () => setState('disconnected'));
+
+    // Subscribe to this room (topic-tag filtered)
+    const now = Math.floor(Date.now() / 1000);
+    const filter = {
+      kinds: [1],
+      '#t': [state.room],
+      since: now - 3600,
+      limit: 200,
+    };
+
+    sendRaw(['REQ', state.subId, filter]);
+
+    // Announce presence
+    await sendJoin();
+
+    setState('connected');
+  }
+
+  async function sendJoin() {
+    ensureKeys();
+    const created_at = Math.floor(Date.now() / 1000);
+    const tags = [
+      ['room', state.room],
+      ['t', state.room],
+    ];
+
+    const eventTemplate = {
+      kind: 1,
+      created_at,
+      tags,
+      content: JSON.stringify({
+        type: 'peer-join',
+        peerId: state.pubkey,
+        room: state.room,
+        timestamp: Date.now(),
+      }),
+      pubkey: state.pubkey,
+    };
+
+    const signed = finalizeEvent(eventTemplate, state.secretKeyHex);
+    sendRaw(['EVENT', signed]);
+  }
+
+  async function sendMessage(text) {
+    ensureKeys();
+    const created_at = Math.floor(Date.now() / 1000);
+    const tags = [
+      ['room', state.room],
+      ['t', state.room],
+    ];
+
+    const eventTemplate = {
+      kind: 1,
+      created_at,
+      tags,
+      content: JSON.stringify({
+        type: 'message',
+        message: text,
+        peerId: state.pubkey,
+        room: state.room,
+        timestamp: Date.now(),
+      }),
+      pubkey: state.pubkey,
+    };
+
+    const signed = finalizeEvent(eventTemplate, state.secretKeyHex);
+    sendRaw(['EVENT', signed]);
+  }
+
+  async function disconnect() {
+    const ws = state.ws;
+    state.ws = null;
+
+    try {
+      if (ws && ws.readyState === WebSocket.OPEN) {
+        try {
+          ws.send(JSON.stringify(['CLOSE', state.subId]));
+        } catch {
+          // ignore
+        }
+        ws.close();
+      }
+    } finally {
+      setState('disconnected');
+    }
+  }
+
+  return {
+    connect,
+    disconnect,
+    sendMessage,
+    getPublicKey: getPublicKeyHex,
+  };
+}

package/src/nostr/useNostr.js

@@ -0,0 +1,6 @@
+export function useNostr() {
+  throw new Error(
+    'useNostr() (Vue composable) is not wired into this demo. ' +
+      'Use createNostrClient() from src/nostr/nostrClient.js instead.'
+  );
+}

package/src/nostr/useWebRTC.js

@@ -0,0 +1,6 @@
+export function useWebRTC() {
+  throw new Error(
+    'useWebRTC() (Vue composable) is not wired into this demo. ' +
+      'The demo page uses src/main.js and (optionally) src/nostr/nostrClient.js.'
+  );
+}

package/src/services/nostrService.js

@@ -0,0 +1,129 @@
+import { subscribe } from 'nostr-tools/relay';
+import { SimplePool } from 'nostr-tools/pool';
+
+// List of public Nostr relays
+const DEFAULT_RELAYS = [
+  'wss://relay.damus.io',
+  'wss://relay.nostr.band',
+  'wss://nostr.wine',
+  'wss://relay.current.fyi'
+];
+
+let pool = new SimplePool();
+let relayConnections = new Map();
+let subscriptions = new Map();
+
+/**
+ * Add or connect to relays
+ */
+export async function addRelays(relayUrls = DEFAULT_RELAYS) {
+  for (const url of relayUrls) {
+    if (!relayConnections.has(url)) {
+      try {
+        await pool.ensureRelay(url);
+        relayConnections.set(url, true);
+        console.log(`Connected to relay: ${url}`);
+      } catch (error) {
+        console.error(`Failed to connect to relay ${url}:`, error);
+      }
+    }
+  }
+}
+
+/**
+ * Ensure relay connection is established
+ */
+export async function ensureRelayConnection(relayUrl = DEFAULT_RELAYS[0]) {
+  if (!relayConnections.has(relayUrl)) {
+    await addRelays([relayUrl]);
+  }
+  return relayConnections.get(relayUrl);
+}
+
+/**
+ * Crawl available relays
+ */
+export async function crawlRelays() {
+  return DEFAULT_RELAYS;
+}
+
+/**
+ * Ensure connections to multiple relays
+ */
+export async function ensureConnections(relayUrls = DEFAULT_RELAYS) {
+  await addRelays(relayUrls);
+}
+
+/**
+ * Publish an event to all connected relays
+ */
+export async function publishEvent(event) {
+  const relayUrls = Array.from(relayConnections.keys());
+  if (relayUrls.length === 0) {
+    await addRelays();
+  }
+  
+  try {
+    const publishPromises = Array.from(relayConnections.keys()).map(url => 
+      pool.publish(url, event).catch(err => {
+        console.error(`Failed to publish to ${url}:`, err);
+      })
+    );
+    await Promise.all(publishPromises);
+    console.log('Event published to all relays');
+  } catch (error) {
+    console.error('Error publishing event:', error);
+  }
+}
+
+/**
+ * Subscribe to events with a filter
+ */
+export async function subscribeToEvents(filter, onEvent, subscriptionId = 'default') {
+  if (relayConnections.size === 0) {
+    await addRelays();
+  }
+
+  try {
+    const relayUrls = Array.from(relayConnections.keys());
+    
+    const subscription = pool.subscribeMany(relayUrls, [filter], {
+      onevent: (event) => onEvent(event),
+      onclose: () => console.log(`Subscription ${subscriptionId} closed`),
+      oneose: () => console.log(`Subscription ${subscriptionId} received all events`)
+    });
+
+    subscriptions.set(subscriptionId, subscription);
+    console.log(`Subscribed with filter:`, filter);
+    return subscriptionId;
+  } catch (error) {
+    console.error('Error subscribing to events:', error);
+  }
+}
+
+/**
+ * Unsubscribe from events
+ */
+export async function unsubscribeFromEvents(subscriptionId = 'default') {
+  const subscription = subscriptions.get(subscriptionId);
+  if (subscription) {
+    subscription.close();
+    subscriptions.delete(subscriptionId);
+    console.log(`Unsubscribed: ${subscriptionId}`);
+  }
+}
+
+/**
+ * Close all relay connections
+ */
+export async function closeAllConnections() {
+  subscriptions.forEach(sub => sub.close());
+  subscriptions.clear();
+  
+  relayConnections.forEach((_, url) => {
+    pool.close(url);
+  });
+  relayConnections.clear();
+  
+  console.log('Closed all relay connections');
+}