uniwrtc 1.0.7 → 1.0.8

package/CLOUDFLARE_DEPLOYMENT.md

@@ -70,7 +70,7 @@ await client.connect();
 ## How It Works
 
 1. **Durable Objects** - One per room, manages peer discovery
-2. **WebSocket** - Browsers connect for signaling
+2. **HTTP polling** - Browsers connect for signaling
 3. **Signaling Only** - Offers/answers/ICE via Worker
 4. **P2P Data** - WebRTC data channels bypass Cloudflare
 5. **Free Tier** - Plenty of capacity for small deployments
@@ -109,7 +109,7 @@ const serverUrl = 'http://localhost:8787/';
 
 ## Troubleshooting
 
-**WebSocket errors**: Ensure your domain is on Cloudflare with SSL enabled
+**Connection errors**: Ensure your domain is on Cloudflare with SSL enabled
 
 **Connection refused**: Check the Worker route pattern in `wrangler.toml`
 

package/README.md

@@ -1,21 +1,53 @@
 # UniWRTC
 
-A universal WebRTC signaling service that provides a simple and flexible WebSocket-based signaling server for WebRTC applications.
+A universal WebRTC signaling service that provides a simple and flexible **HTTP polling** signaling server for WebRTC applications.
 
 Available on npm: https://www.npmjs.com/package/uniwrtc
 
 ## Features
 
-- 🚀 **Simple WebSocket-based signaling** - Easy to integrate with any WebRTC application
+- 🚀 **Simple signaling** - HTTP polling (works locally and on Cloudflare Durable Objects)
 - 🏠 **Session-based architecture** - Support for multiple sessions with isolated peer groups
 - 🔌 **Flexible client library** - Ready-to-use JavaScript client for browser and Node.js
 - 📡 **Real-time messaging** - Efficient message routing between peers
 - 🔄 **Auto-reconnection** - Built-in reconnection logic for reliable connections
 - 📊 **Health monitoring** - HTTP health check endpoint for monitoring
-- 🎯 **Minimal dependencies** - Lightweight implementation using only the `ws` package
+- 🎯 **Minimal dependencies** - Lightweight implementation with minimal runtime deps
 
 ## Quick Start
 
+## Using with `simple-peer` (SDP text-only)
+
+This repo's signaling format sends **SDP as plain text** for offers/answers.
+`simple-peer` uses `{ type, sdp }` objects, so use the adapter in [simple-peer-adapter.js](simple-peer-adapter.js).
+
+Example (browser):
+
+```js
+import Peer from 'simple-peer';
+import UniWRTCClient from './client-browser.js';
+import { sendSimplePeerSignal, attachUniWRTCToSimplePeer, chooseDeterministicInitiator } from './simple-peer-adapter.js';
+
+const client = new UniWRTCClient('https://your-signal-server', { roomId: 'my-room' });
+await client.connect();
+
+// Join a session (peers in the same session can connect)
+await client.joinSession('my-room');
+
+// Ensure exactly ONE side initiates for a given pair
+const initiator = chooseDeterministicInitiator(client.clientId, targetId);
+const peer = new Peer({ initiator, trickle: true });
+const cleanup = attachUniWRTCToSimplePeer(client, peer);
+
+peer.on('signal', (signal) => {
+  // targetId must be the other peer's UniWRTC client id
+  sendSimplePeerSignal(client, signal, targetId);
+});
+
+// When done:
+// cleanup();
+```
+
 ### Installation
 
 #### From npm (recommended)
@@ -63,7 +95,7 @@ The interactive demo is available live at **https://signal.peer.ooo/** (Cloudfla
 5. Open the P2P chat and send messages between tabs
 
 **Or run locally:**
-1. Start the server: `npm start` (signaling at `ws://localhost:8080`)
+1. Start the server: `npm start` (signaling at `http://localhost:8080`)
 2. Start the Vite dev server: `npm run dev` (demo at `http://localhost:5173/`)
 3. Open the demo in two browser tabs
 4. Enter the same session ID in both, then Connect
@@ -73,7 +105,8 @@ The interactive demo is available live at **https://signal.peer.ooo/** (Cloudfla
 
 ### Server API
 
-The signaling server accepts WebSocket connections and supports the following message types:
+The signaling server supports:
+- HTTP polling signaling (no WebSockets)
 
 #### Client → Server Messages
 
@@ -97,7 +130,7 @@ The signaling server accepts WebSocket connections and supports the following me
 ```json
 {
   "type": "offer",
-  "offer": { /* RTCSessionDescription */ },
+  "offer": "v=0\r\n...",
   "targetId": "peer-client-id",
   "sessionId": "session-123"
 }
@@ -107,7 +140,7 @@ The signaling server accepts WebSocket connections and supports the following me
 ```json
 {
   "type": "answer",
-  "answer": { /* RTCSessionDescription */ },
+  "answer": "v=0\r\n...",
   "targetId": "peer-client-id",
   "sessionId": "session-123"
 }
@@ -117,7 +150,7 @@ The signaling server accepts WebSocket connections and supports the following me
 ```json
 {
   "type": "ice-candidate",
-  "candidate": { /* RTCIceCandidate */ },
+  "candidate": "candidate:...|0|0",
   "targetId": "peer-client-id",
   "sessionId": "session-123"
 }
@@ -175,16 +208,13 @@ Use directly from npm:
 ```javascript
 // ESM (browser)
 import UniWRTCClient from 'uniwrtc/client-browser.js';
-
-// CommonJS (Node.js)
-const UniWRTCClient = require('uniwrtc/client.js');
 ```
 
 The `client.js` library provides a convenient wrapper for the signaling protocol:
 
 ```javascript
 // Create a client instance
-const client = new UniWRTCClient('ws://localhost:8080');
+const client = new UniWRTCClient('http://localhost:8080', { roomId: 'my-room' });
 
 // Set up event handlers
 client.on('connected', (data) => {
@@ -220,7 +250,7 @@ client.on('ice-candidate', (data) => {
 await client.connect();
 
 // Join a session
-client.joinSession('my-session');
+await client.joinSession('my-session');
 
 // Send WebRTC signaling messages
 client.sendOffer(offerObject, targetPeerId);
@@ -233,7 +263,7 @@ client.sendIceCandidate(candidateObject, targetPeerId);
 Here's a complete example of creating a WebRTC peer connection:
 
 ```javascript
-const client = new UniWRTCClient('ws://localhost:8080');
+const client = new UniWRTCClient('http://localhost:8080', { roomId: 'my-room' });
 const peerConnections = new Map();
 
 // ICE server configuration
@@ -281,7 +311,7 @@ client.on('peer-joined', async (data) => {
 client.on('offer', async (data) => {
   const pc = createPeerConnection(data.peerId);
   
-  await pc.setRemoteDescription(data.offer);
+  await pc.setRemoteDescription({ type: 'offer', sdp: data.offer });
   const answer = await pc.createAnswer();
   await pc.setLocalDescription(answer);
   client.sendAnswer(answer, data.peerId);
@@ -291,7 +321,7 @@ client.on('offer', async (data) => {
 client.on('answer', async (data) => {
   const pc = peerConnections.get(data.peerId);
   if (pc) {
-    await pc.setRemoteDescription(data.answer);
+    await pc.setRemoteDescription({ type: 'answer', sdp: data.answer });
   }
 });
 
@@ -299,7 +329,12 @@ client.on('answer', async (data) => {
 client.on('ice-candidate', async (data) => {
   const pc = peerConnections.get(data.peerId);
   if (pc) {
-    await pc.addIceCandidate(data.candidate);
+    const [candidate, sdpMidRaw, sdpMLineIndexRaw] = String(data.candidate).split('|');
+    await pc.addIceCandidate(new RTCIceCandidate({
+      candidate,
+      sdpMid: sdpMidRaw || undefined,
+      sdpMLineIndex: sdpMLineIndexRaw !== undefined && sdpMLineIndexRaw !== '' ? Number(sdpMLineIndexRaw) : undefined
+    }));
   }
 });
 
@@ -307,8 +342,8 @@ client.on('ice-candidate', async (data) => {
 await client.connect();
 client.joinSession('my-video-session');
 
-// Or use Cloudflare Durable Objects deployment
-const cfClient = new UniWRTCClient('wss://signal.peer.ooo?room=my-session');
+// Or use Cloudflare Durable Objects deployment (HTTP polling; no WebSockets)
+const cfClient = new UniWRTCClient('https://signal.peer.ooo');
 await cfClient.connect();
 cfClient.joinSession('my-session');
 ```
@@ -323,7 +358,7 @@ new UniWRTCClient(serverUrl, options)
 ```
 
 **Parameters:**
-- `serverUrl` (string): WebSocket URL of the signaling server
+- `serverUrl` (string): HTTP(S) URL of the signaling server
 - `options` (object, optional):
   - `autoReconnect` (boolean): Enable automatic reconnection (default: true)
   - `reconnectDelay` (number): Delay between reconnection attempts in ms (default: 3000)
@@ -382,20 +417,25 @@ Response:
 
 ### Message Flow
 
-1. Client connects via WebSocket (or WS-over-HTTP for Cloudflare)
+1. Client connects via HTTPS (Cloudflare DO HTTP polling)
 2. Server/Durable Object assigns a unique client ID
 3. Client sends join message with session ID
 4. Server broadcasts `peer-joined` to other peers in the same session only
 5. Peers exchange WebRTC offers/answers/ICE candidates via the server
 6. Server routes signaling messages to specific peers by target ID (unicast, not broadcast)
 
+Notes:
+- Cloudflare signaling uses JSON over HTTPS requests to `/api` (polling).
+- Offers/answers are transmitted as SDP strings (text-only) in the `offer`/`answer` fields.
+- ICE candidates are transmitted as a compact text string: `candidate|sdpMid|sdpMLineIndex`.
+
 ## Security Considerations
 
 This is a basic signaling server suitable for development and testing. For production use, consider:
 
 - Adding authentication and authorization
 - Implementing rate limiting
-- Using TLS/WSS for encrypted connections
+- Using TLS/HTTPS for encrypted connections
 - Adding room access controls
 - Implementing message validation
 - Monitoring and logging

package/client-browser.js

@@ -1,265 +1,13 @@
 /**
  * UniWRTC Client - WebRTC Signaling Client Library
- * Browser-only version
+ * Browser version (HTTP polling; no WebSockets)
  */
 
-class UniWRTCClient {
-  constructor(serverUrl, options = {}) {
-    this.serverUrl = serverUrl;
-    this.ws = null;
-    this.clientId = null;
-    this.sessionId = null;
-    this.peers = new Map();
-    this._connectedOnce = false;
-    this.options = {
-      autoReconnect: true,
-      reconnectDelay: 3000,
-      ...options
-    };
-    this.eventHandlers = {
-      'connected': [],
-      'disconnected': [],
-      'joined': [],
-      'peer-joined': [],
-      'peer-left': [],
-      'offer': [],
-      'answer': [],
-      'ice-candidate': [],
-      'room-list': [],
-      'error': []
-    };
-  }
-
-  connect() {
-    return new Promise((resolve, reject) => {
-      try {
-        this.ws = new WebSocket(this.serverUrl);
-
-        this.ws.onopen = () => {
-          console.log('Connected to signaling server');
-          
-          // Send custom peer ID if provided
-          if (this.options.customPeerId) {
-            this.send({
-              type: 'set-id',
-              customId: this.options.customPeerId
-            });
-          }
-        };
-
-        this.ws.onmessage = (event) => {
-          try {
-            const message = JSON.parse(event.data);
-            this.handleMessage(message);
-
-            if (message.type === 'welcome' && !this._connectedOnce) {
-              this.clientId = message.clientId;
-              this._connectedOnce = true;
-              this.emit('connected', { clientId: this.clientId });
-              resolve(this.clientId);
-            }
-          } catch (error) {
-            console.error('Error parsing message:', error);
-          }
-        };
-
-        this.ws.onclose = () => {
-          console.log('Disconnected from signaling server');
-          this.emit('disconnected');
-          
-          if (this.options.autoReconnect) {
-            setTimeout(() => {
-              console.log('Attempting to reconnect...');
-              this.connect();
-            }, this.options.reconnectDelay);
-          }
-        };
-
-        this.ws.onerror = (error) => {
-          console.error('WebSocket error:', error);
-          reject(error);
-        };
-      } catch (error) {
-        reject(error);
-      }
-    });
-  }
-
-  disconnect() {
-    if (this.ws) {
-      this.options.autoReconnect = false;
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-
-  joinSession(sessionId) {
-    // Prevent duplicate join calls for the same session
-    if (this.sessionId === sessionId) return;
-    this.sessionId = sessionId;
-    
-    // Send join message
-    this.send({
-      type: 'join',
-      sessionId: sessionId,
-      peerId: this.clientId
-    });
-  }
-
-  leaveSession() {
-    if (this.sessionId) {
-      this.send({
-        type: 'leave',
-        sessionId: this.sessionId
-      });
-      this.sessionId = null;
-    }
-  }
-
-  send(message) {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify(message));
-    } else {
-      console.warn('WebSocket is not connected');
-    }
-  }
-
-  sendOffer(offer, targetId) {
-    console.log(`[Client] Sending offer to ${targetId}`);
-    this.send({
-      type: 'offer',
-      offer: offer,
-      targetId: targetId,
-      sessionId: this.sessionId
-    });
-  }
-
-  sendAnswer(answer, targetId) {
-    console.log(`[Client] Sending answer to ${targetId}`);
-    this.send({
-      type: 'answer',
-      answer: answer,
-      targetId: targetId,
-      sessionId: this.sessionId
-    });
-  }
-
-  sendIceCandidate(candidate, targetId) {
-    console.log(`[Client] Sending ICE candidate to ${targetId}`);
-    this.send({
-      type: 'ice-candidate',
-      candidate: candidate,
-      targetId: targetId,
-      sessionId: this.sessionId
-    });
-  }
-
-  listRooms() {
-    this.send({
-      type: 'list-rooms'
-    });
-  }
-
-  on(event, handler) {
-    if (this.eventHandlers[event]) {
-      this.eventHandlers[event].push(handler);
-    }
-  }
-
-  off(event, handler) {
-    if (this.eventHandlers[event]) {
-      this.eventHandlers[event] = this.eventHandlers[event].filter(h => h !== handler);
-    }
-  }
-
-  emit(event, data) {
-    if (this.eventHandlers[event]) {
-      this.eventHandlers[event].forEach(handler => {
-        try {
-          handler(data);
-        } catch (error) {
-          console.error(`Error in ${event} handler:`, error);
-        }
-      });
-    }
-  }
-
-  handleMessage(message) {
-    switch (message.type) {
-      case 'welcome':
-        // Only set clientId here; 'connected' is emitted in connect() with a guard
-        this.clientId = message.clientId;
-        console.log('[UniWRTC] If this helps, consider donating ❤️ → https://coff.ee/draederg');
-        break;
-      case 'joined':
-        this.sessionId = message.sessionId;
-        this.emit('joined', {
-          sessionId: message.sessionId,
-          peerId: message.peerId,
-          clientId: message.clientId,
-          clients: message.clients
-        });
-        break;
-      case 'peer-joined':
-        this.emit('peer-joined', {
-          sessionId: message.sessionId,
-          peerId: message.peerId
-        });
-        break;
-      case 'peer-left':
-        this.emit('peer-left', {
-          sessionId: message.sessionId,
-          peerId: message.peerId
-        });
-        break;
-      case 'offer':
-        console.log(`[Client] Received offer from ${message.peerId}`);
-        this.emit('offer', {
-          peerId: message.peerId,
-          offer: message.offer
-        });
-        break;
-      case 'answer':
-        console.log(`[Client] Received answer from ${message.peerId}`);
-        this.emit('answer', {
-          peerId: message.peerId,
-          answer: message.answer
-        });
-        break;
-      case 'ice-candidate':
-        console.log(`[Client] Received ICE candidate from ${message.peerId}`);
-        this.emit('ice-candidate', {
-          peerId: message.peerId,
-          candidate: message.candidate
-        });
-        break;
-      case 'room-list':
-        this.emit('room-list', {
-          rooms: message.rooms
-        });
-        break;
-      case 'error':
-        this.emit('error', {
-          message: message.message
-        });
-        break;
-      case 'chat':
-        this.emit('chat', {
-          text: message.text,
-          peerId: message.peerId,
-          sessionId: message.sessionId
-        });
-        break;
-      default:
-        console.log('Unknown message type:', message.type);
-    }
-  }
-}
+import UniWRTCClient from './src/client-cloudflare.js';
 
 // Attach to window for non-module script usage
 if (typeof window !== 'undefined') {
   window.UniWRTCClient = UniWRTCClient;
 }
 
-// ESM default export for bundlers like Vite
 export default UniWRTCClient;