uniwrtc 1.0.0

package/src/client-cloudflare.js

@@ -0,0 +1,247 @@
+/**
+ * UniWRTC Client - Updated for Cloudflare deployment
+ * WebRTC Signaling Client Library
+ * Browser-only version
+ */
+
+class UniWRTCClient {
+  constructor(serverUrl, options = {}) {
+    // Support both direct URLs and room parameter format
+    if (!serverUrl.includes('?')) {
+      const roomId = options.roomId || 'default';
+      this.serverUrl = serverUrl + (serverUrl.endsWith('/') ? '' : '/') + `signaling?room=${roomId}`;
+    } else {
+      this.serverUrl = serverUrl;
+    }
+    
+    this.ws = null;
+    this.clientId = null;
+    this.roomId = options.roomId || 'default';
+    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 {
+        // Convert https to wss, http to ws
+        let wsUrl = this.serverUrl;
+        if (wsUrl.startsWith('https://')) {
+          wsUrl = 'wss://' + wsUrl.substring(8);
+        } else if (wsUrl.startsWith('http://')) {
+          wsUrl = 'ws://' + wsUrl.substring(7);
+        }
+
+        this.ws = new WebSocket(wsUrl);
+
+        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;
+    }
+  }
+
+  joinRoom(roomId) {
+    this.roomId = roomId;
+    // Durable Objects handle room joining automatically via room parameter
+  }
+
+  leaveRoom() {
+    if (this.roomId) {
+      this.roomId = 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(targetId, offer) {
+    this.send({
+      type: 'offer',
+      offer: offer,
+      targetId: targetId
+    });
+  }
+
+  sendAnswer(targetId, answer) {
+    this.send({
+      type: 'answer',
+      answer: answer,
+      targetId: targetId
+    });
+  }
+
+  sendIceCandidate(targetId, candidate) {
+    this.send({
+      type: 'ice-candidate',
+      candidate: candidate,
+      targetId: targetId
+    });
+  }
+
+  listRooms() {
+    // Durable Objects don't expose room listing
+    console.log('Room listing not available with Durable Objects');
+  }
+
+  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':
+        this.clientId = message.clientId;
+        console.log('[UniWRTC] If this helps, consider donating ❤️ → https://coff.ee/draederg');
+        break;
+      case 'joined':
+        this.roomId = message.roomId;
+        this.emit('joined', {
+          roomId: message.roomId,
+          clientId: message.clientId,
+          clients: message.clients
+        });
+        break;
+      case 'peer-joined':
+        this.emit('peer-joined', {
+          clientId: message.clientId
+        });
+        break;
+      case 'peer-left':
+        this.emit('peer-left', {
+          clientId: message.clientId
+        });
+        break;
+      case 'offer':
+        this.emit('offer', {
+          peerId: message.peerId,
+          offer: message.offer
+        });
+        break;
+      case 'answer':
+        this.emit('answer', {
+          peerId: message.peerId,
+          answer: message.answer
+        });
+        break;
+      case 'ice-candidate':
+        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,
+          senderId: message.senderId,
+          roomId: message.roomId
+        });
+        break;
+      default:
+        console.log('Unknown message type:', message.type);
+    }
+  }
+}

package/src/index.js

@@ -0,0 +1,35 @@
+/**
+ * UniWRTC Cloudflare Worker
+ * WebRTC Signaling Service using Durable Objects
+ */
+
+import { Room } from './room.js';
+
+export { Room };
+
+export default {
+  async fetch(request, env) {
+    const url = new URL(request.url);
+
+    // Health check
+    if (url.pathname === '/health') {
+      return new Response(JSON.stringify({ status: 'ok' }), {
+        headers: { 'Content-Type': 'application/json' }
+      });
+    }
+
+    // WebSocket signaling
+    if (url.pathname === '/signaling' || url.pathname === '/') {
+      const roomId = url.searchParams.get('room') || 'default';
+
+      // Get Durable Object stub for this room
+      const id = env.ROOMS.idFromName(roomId);
+      const roomStub = env.ROOMS.get(id);
+
+      // Forward request to Durable Object
+      return roomStub.fetch(request);
+    }
+
+    return new Response('Not Found', { status: 404 });
+  }
+};

package/src/room.js

@@ -0,0 +1,211 @@
+/**
+ * Durable Object for WebRTC Signaling Room
+ * Manages peers in a room and routes signaling messages
+ */
+export class Room {
+  constructor(state, env) {
+    this.state = state;
+    this.env = env;
+    this.clients = new Map(); // Map of clientId -> WebSocket
+  }
+
+  async fetch(request) {
+    if (request.headers.get('Upgrade') === 'websocket') {
+      const [client, server] = Object.values(new WebSocketPair());
+      server.accept();
+
+      const clientId = crypto.randomUUID().substring(0, 9);
+      this.clients.set(clientId, server);
+
+      console.log(`[Room] Client ${clientId} joined (total: ${this.clients.size})`);
+
+      // Send welcome message
+      server.send(JSON.stringify({
+        type: 'welcome',
+        clientId: clientId,
+        message: 'Connected to UniWRTC signaling room'
+      }));
+
+      // Notify existing clients
+      this.broadcast({
+        type: 'peer-joined',
+        clientId: clientId
+      }, clientId);
+
+      server.onmessage = async (event) => {
+        try {
+          const message = JSON.parse(event.data);
+          await this.handleMessage(clientId, message);
+        } catch (error) {
+          console.error('[Room] Message error:', error);
+          server.send(JSON.stringify({ type: 'error', message: error.message }));
+        }
+      };
+
+      server.onclose = () => {
+        console.log(`[Room] Client ${clientId} left`);
+        this.clients.delete(clientId);
+        this.broadcast({
+          type: 'peer-left',
+          peerId: clientId,
+          clientId: clientId
+        });
+      };
+
+      server.onerror = (error) => {
+        console.error('[Room] WebSocket error:', error);
+      };
+
+      return new Response(null, { status: 101, webSocket: client });
+    }
+
+    return new Response('Not a WebSocket request', { status: 400 });
+  }
+
+  async handleMessage(clientId, message) {
+    switch (message.type) {
+      case 'join':
+        await this.handleJoin(clientId, message);
+        break;
+      case 'set-id':
+        await this.handleSetId(clientId, message);
+        break;
+      case 'offer':
+      case 'answer':
+      case 'ice-candidate':
+        await this.handleSignaling(clientId, message);
+        break;
+      default:
+        console.log(`[Room] Unknown message type: ${message.type}`);
+    }
+  }
+
+  async handleJoin(clientId, message) {
+    const { roomId, peerId } = message;
+    
+    // Get list of other peers
+    const peers = Array.from(this.clients.keys())
+      .filter(id => id !== clientId);
+    
+    const client = this.clients.get(clientId);
+    if (client && client.readyState === WebSocket.OPEN) {
+      // Send joined confirmation
+      client.send(JSON.stringify({
+        type: 'joined',
+        roomId: roomId,
+        peerId: peerId || clientId,
+        clients: peers
+      }));
+    }
+    
+    // Notify other peers
+    this.broadcast({
+      type: 'peer-joined',
+      peerId: peerId || clientId,
+      clientId: clientId
+    }, clientId);
+  }
+
+  async handleSetId(clientId, message) {
+    const { customId } = message;
+    
+    if (!customId || customId.length < 3 || customId.length > 20) {
+      const client = this.clients.get(clientId);
+      if (client && client.readyState === WebSocket.OPEN) {
+        client.send(JSON.stringify({
+          type: 'error',
+          message: 'Custom ID must be 3-20 characters'
+        }));
+      }
+      return;
+    }
+
+    // Check if ID is already taken
+    let idTaken = false;
+    for (const [id, ws] of this.clients) {
+      if (id !== clientId && id === customId) {
+        idTaken = true;
+        break;
+      }
+    }
+
+    if (idTaken) {
+      const client = this.clients.get(clientId);
+      if (client && client.readyState === WebSocket.OPEN) {
+        client.send(JSON.stringify({
+          type: 'error',
+          message: 'Peer ID already taken'
+        }));
+      }
+      return;
+    }
+
+    // Update client ID
+    const ws = this.clients.get(clientId);
+    this.clients.delete(clientId);
+    this.clients.set(customId, ws);
+
+    console.log(`[Room] Client changed ID from ${clientId} to ${customId}`);
+
+    // Send confirmation
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({
+        type: 'welcome',
+        clientId: customId,
+        message: 'Custom peer ID set'
+      }));
+    }
+
+    // Notify others of ID change
+    this.broadcast({
+      type: 'peer-id-changed',
+      oldId: clientId,
+      newId: customId
+    });
+  }
+
+  async handleSignaling(clientId, message) {
+    const { targetId, type, offer, answer, candidate } = message;
+
+    if (!targetId) {
+      console.log(`[Room] Signaling without target`);
+      return;
+    }
+
+    const targetClient = this.clients.get(targetId);
+    if (!targetClient || targetClient.readyState !== WebSocket.OPEN) {
+      console.log(`[Room] Target client ${targetId} not found or closed`);
+      const client = this.clients.get(clientId);
+      if (client && client.readyState === WebSocket.OPEN) {
+        client.send(JSON.stringify({
+          type: 'error',
+          message: `Target peer ${targetId} not found`
+        }));
+      }
+      return;
+    }
+
+    console.log(`[Room] Routing ${type} from ${clientId} to ${targetId}`);
+
+    // Route signaling message to target
+    const forwardMessage = {
+      type: type,
+      peerId: clientId
+    };
+
+    if (offer) forwardMessage.offer = offer;
+    if (answer) forwardMessage.answer = answer;
+    if (candidate) forwardMessage.candidate = candidate;
+
+    targetClient.send(JSON.stringify(forwardMessage));
+  }
+
+  broadcast(message, excludeClientId = null) {
+    const payload = JSON.stringify(message);
+    for (const [clientId, client] of this.clients) {
+      if (clientId !== excludeClientId && client.readyState === WebSocket.OPEN) {
+        client.send(payload);
+      }
+    }
+  }
+}

package/test.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+/**
+ * Simple test script for UniWRTC
+ * Runs two clients and tests peer connections
+ */
+
+const { UniWRTCClient } = require('./client.js');
+
+async function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function runTest() {
+  console.log('🚀 Starting UniWRTC Test...\n');
+
+  // Create two clients
+  const client1 = new UniWRTCClient('ws://localhost:8080');
+  const client2 = new UniWRTCClient('ws://localhost:8080');
+
+  try {
+    // Connect first client
+    console.log('📱 Connecting Client 1...');
+    const id1 = await client1.connect();
+    console.log(`✅ Client 1 connected with ID: ${id1}\n`);
+
+    await sleep(500);
+
+    // Connect second client
+    console.log('📱 Connecting Client 2...');
+    const id2 = await client2.connect();
+    console.log(`✅ Client 2 connected with ID: ${id2}\n`);
+
+    await sleep(500);
+
+    // Join same room
+    console.log('🏠 Client 1 joining room: test-room');
+    client1.joinRoom('test-room');
+    
+    await sleep(500);
+
+    console.log('🏠 Client 2 joining room: test-room');
+    client2.joinRoom('test-room');
+
+    await sleep(1000);
+
+    console.log('\n✨ Test complete! Both clients joined the room.');
+    console.log('📊 Peers in Client 1:', Array.from(client1.peers.keys()));
+    console.log('📊 Peers in Client 2:', Array.from(client2.peers.keys()));
+
+    // Cleanup
+    client1.disconnect();
+    client2.disconnect();
+    
+    process.exit(0);
+  } catch (error) {
+    console.error('❌ Test failed:', error.message);
+    process.exit(1);
+  }
+}
+
+runTest();

package/wrangler.toml

@@ -0,0 +1,23 @@
+name = "uniwrtc"
+main = "src/index.js"
+compatibility_date = "2024-12-20"
+
+[[migrations]]
+tag = "v1"
+new_sqlite_classes = ["Room"]
+
+[[durable_objects.bindings]]
+name = "ROOMS"
+class_name = "Room"
+
+[env.production]
+routes = [
+  { pattern = "signal.peer.ooo/*", zone_name = "peer.ooo" }
+]
+
+[[env.production.durable_objects.bindings]]
+name = "ROOMS"
+class_name = "Room"
+
+[build]
+command = "npm install"