uniwrtc 1.0.8 → 1.0.9

package/client-browser.js

@@ -1,13 +1,265 @@
 /**
  * UniWRTC Client - WebRTC Signaling Client Library
- * Browser version (HTTP polling; no WebSockets)
+ * Browser-only version
  */
 
-import UniWRTCClient from './src/client-cloudflare.js';
+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);
+    }
+  }
+}
 
 // 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;

package/client.js

@@ -1,69 +1,20 @@
 /**
- * UniWRTC Client - Node.js client (HTTP polling; no WebSockets)
+ * UniWRTC Client - WebRTC Signaling Client Library
+ * Simplifies connection to the UniWRTC signaling server
  */
 
-import http from 'http';
-import https from 'https';
-
-function requestJson(urlString, { method, body } = {}) {
-  return new Promise((resolve, reject) => {
-    const url = new URL(urlString);
-    const isHttps = url.protocol === 'https:';
-    const lib = isHttps ? https : http;
-
-    const payload = body === undefined ? null : JSON.stringify(body);
-    const req = lib.request(
-      {
-        hostname: url.hostname,
-        port: url.port || (isHttps ? 443 : 80),
-        path: url.pathname + url.search,
-        method: method || 'GET',
-        headers: {
-          ...(payload ? { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) } : {}),
-          'Accept': 'application/json'
-        }
-      },
-      (res) => {
-        let data = '';
-        res.on('data', (chunk) => (data += chunk));
-        res.on('end', () => {
-          const status = res.statusCode || 0;
-          let parsed = null;
-          try {
-            parsed = data ? JSON.parse(data) : null;
-          } catch {
-            parsed = null;
-          }
-          if (status >= 200 && status < 300) return resolve(parsed);
-          const message = parsed?.message || `HTTP ${status}`;
-          const err = new Error(message);
-          err.status = status;
-          err.body = parsed;
-          return reject(err);
-        });
-      }
-    );
-    req.on('error', reject);
-    if (payload) req.write(payload);
-    req.end();
-  });
-}
-
-export class UniWRTCClient {
+class UniWRTCClient {
   constructor(serverUrl, options = {}) {
     this.serverUrl = serverUrl;
+    this.ws = null;
     this.clientId = null;
     this.sessionId = null;
-    this._pollTimer = null;
-
+    this.peers = new Map();
     this.options = {
       autoReconnect: true,
       reconnectDelay: 3000,
-      pollIntervalMs: 500,
-      roomId: options.roomId || 'default',
       ...options
     };
-
     this.eventHandlers = {
       'connected': [],
       'disconnected': [],
@@ -78,147 +29,128 @@ export class UniWRTCClient {
     };
   }
 
-  baseOrigin() {
-    const parsed = new URL(this.serverUrl);
-    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
-      throw new Error('Server URL must start with http(s):// (WebSockets are disabled)');
-    }
-    return parsed.origin;
-  }
-
-  apiUrl(pathname, extraSearch = {}) {
-    const origin = this.baseOrigin();
-    const url = new URL(origin + pathname);
-    url.searchParams.set('room', this.options.roomId);
-    for (const [k, v] of Object.entries(extraSearch)) {
-      if (v !== undefined && v !== null) url.searchParams.set(k, String(v));
-    }
-    return url.toString();
-  }
-
-  async postJson(pathname, body) {
-    return requestJson(this.apiUrl(pathname), { method: 'POST', body });
-  }
-
-  startPolling() {
-    if (this._pollTimer) return;
-    this._pollTimer = setInterval(() => {
-      this.pollOnce().catch((err) => {
-        this.emit('error', { message: err?.message || String(err) });
-      });
-    }, this.options.pollIntervalMs);
-  }
-
-  stopPolling() {
-    if (this._pollTimer) {
-      clearInterval(this._pollTimer);
-      this._pollTimer = null;
-    }
-  }
-
-  async connect() {
-    try {
-      const welcome = await this.postJson('/api/connect', {});
-      this.clientId = welcome?.clientId;
-      if (!this.clientId) throw new Error('Missing clientId from server');
+  connect() {
+    return new Promise((resolve, reject) => {
+      try {
+        // Get WebSocket class (browser or Node.js)
+        const WSClass = typeof WebSocket !== 'undefined' ? WebSocket : require('ws');
+        this.ws = new WSClass(this.serverUrl);
 
-      if (this.options.customPeerId) {
-        const res = await this.postJson('/api/set-id', {
-          clientId: this.clientId,
-          customId: this.options.customPeerId
-        });
-        this.clientId = res?.clientId || this.clientId;
-      }
+        this.ws.onopen = () => {
+          console.log('Connected to signaling server');
+        };
 
-      this.emit('connected', { clientId: this.clientId });
-      this.startPolling();
-      return this.clientId;
-    } catch (error) {
-      this.emit('error', { message: error?.message || String(error) });
-      if (this.options.autoReconnect) {
-        setTimeout(() => this.connect(), this.options.reconnectDelay);
+        this.ws.onmessage = (event) => {
+          try {
+            const message = JSON.parse(event.data);
+            this.handleMessage(message);
+
+            if (message.type === 'welcome') {
+              this.clientId = message.clientId;
+              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);
       }
-      throw error;
-    }
+    });
   }
 
-  async disconnect() {
-    this.options.autoReconnect = false;
-    this.stopPolling();
-    if (this.clientId) {
-      try {
-        await this.postJson('/api/leave', { clientId: this.clientId });
-      } catch {
-        // ignore
-      }
+  disconnect() {
+    if (this.ws) {
+      this.options.autoReconnect = false;
+      this.ws.close();
+      this.ws = null;
     }
-    this.emit('disconnected');
   }
 
-  async joinSession(sessionId) {
-    if (!this.clientId) throw new Error('Not connected');
-    if (this.sessionId === sessionId) return;
+  joinSession(sessionId) {
     this.sessionId = sessionId;
-
-    const joined = await this.postJson('/api/join', { clientId: this.clientId, sessionId });
-    this.emit('joined', {
-      sessionId: joined?.sessionId,
-      clientId: joined?.clientId,
-      clients: joined?.clients
+    this.send({
+      type: 'join',
+      sessionId: sessionId
     });
   }
 
-  async leaveSession() {
-    this.sessionId = null;
-  }
-
-  async pollOnce() {
-    if (!this.clientId) return;
-    const data = await requestJson(this.apiUrl('/api/poll', { clientId: this.clientId }), { method: 'GET' });
-    const messages = Array.isArray(data?.messages) ? data.messages : [];
-    for (const msg of messages) this.handleMessage(msg);
+  leaveSession() {
+    if (this.sessionId) {
+      this.send({
+        type: 'leave',
+        sessionId: this.sessionId
+      });
+      this.sessionId = null;
+    }
   }
 
-  async sendSignal(payload) {
-    if (!this.clientId) throw new Error('Not connected');
-    await this.postJson('/api/signal', {
-      clientId: this.clientId,
-      sessionId: this.sessionId,
-      ...payload
+  sendOffer(offer, targetId = null) {
+    this.send({
+      type: 'offer',
+      offer: offer,
+      targetId: targetId,
+      sessionId: this.sessionId
     });
   }
 
-  sendOffer(offer, targetId) {
-    const offerSdp = typeof offer === 'string' ? offer : offer?.sdp;
-    return this.sendSignal({ type: 'offer', offer: offerSdp, targetId });
-  }
-
   sendAnswer(answer, targetId) {
-    const answerSdp = typeof answer === 'string' ? answer : answer?.sdp;
-    return this.sendSignal({ type: 'answer', answer: answerSdp, targetId });
+    this.send({
+      type: 'answer',
+      answer: answer,
+      targetId: targetId,
+      sessionId: this.sessionId
+    });
   }
 
-  sendIceCandidate(candidate, targetId) {
-    const candidateText =
-      typeof candidate === 'string'
-        ? candidate
-        : candidate && typeof candidate === 'object' && typeof candidate.candidate === 'string'
-          ? `${candidate.candidate}|${candidate.sdpMid ?? ''}|${candidate.sdpMLineIndex ?? ''}`
-          : candidate;
-    return this.sendSignal({ type: 'ice-candidate', candidate: candidateText, targetId });
+  sendIceCandidate(candidate, targetId = null) {
+    this.send({
+      type: 'ice-candidate',
+      candidate: candidate,
+      targetId: targetId,
+      sessionId: this.sessionId
+    });
   }
 
   listRooms() {
-    console.log('Room listing not available with HTTP polling');
+    this.send({
+      type: 'list-rooms'
+    });
+  }
+
+  send(message) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(message));
+    } else {
+      console.error('WebSocket is not connected');
+    }
   }
 
   handleMessage(message) {
     switch (message.type) {
       case 'welcome':
-        this.clientId = message.clientId;
+        // Handled in connect(), but also surface donation message
+        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,
           clientId: message.clientId,
@@ -226,50 +158,76 @@ export class UniWRTCClient {
         });
         break;
       case 'peer-joined':
-        this.emit('peer-joined', { sessionId: message.sessionId, peerId: message.peerId });
+        this.emit('peer-joined', {
+          sessionId: message.sessionId,
+          peerId: message.peerId
+        });
         break;
       case 'peer-left':
-        this.emit('peer-left', { sessionId: message.sessionId, peerId: message.peerId });
+        this.emit('peer-left', {
+          sessionId: message.sessionId,
+          peerId: message.peerId
+        });
         break;
       case 'offer':
-        this.emit('offer', { peerId: message.peerId, offer: message.offer });
+        this.emit('offer', {
+          peerId: message.peerId,
+          offer: message.offer
+        });
         break;
       case 'answer':
-        this.emit('answer', { peerId: message.peerId, answer: message.answer });
+        this.emit('answer', {
+          peerId: message.peerId,
+          answer: message.answer
+        });
         break;
       case 'ice-candidate':
-        this.emit('ice-candidate', { peerId: message.peerId, candidate: message.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 });
+        this.emit('error', {
+          message: message.message
+        });
         break;
       default:
-        // ignore
-        break;
+        console.warn('Unknown message type:', message.type);
     }
   }
 
   on(event, handler) {
-    if (this.eventHandlers[event]) this.eventHandlers[event].push(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);
+      this.eventHandlers[event] = this.eventHandlers[event].filter(h => h !== handler);
     }
   }
 
   emit(event, data) {
     if (this.eventHandlers[event]) {
-      for (const handler of this.eventHandlers[event]) {
+      this.eventHandlers[event].forEach(handler => {
         try {
           handler(data);
         } catch (error) {
           console.error(`Error in ${event} handler:`, error);
         }
-      }
+      });
     }
   }
 }
 
-export default UniWRTCClient;
+// Export for Node.js and browser
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = { UniWRTCClient };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uniwrtc",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "A universal WebRTC signaling service",
   "main": "server.js",
   "type": "module",

package/src/client-cloudflare.js

@@ -1,23 +1,29 @@
 /**
- * UniWRTC Client - Cloudflare Durable Objects (HTTP polling)
- * No WebSockets.
+ * UniWRTC Client - Updated for Cloudflare deployment
+ * WebRTC Signaling Client Library
+ * Browser-only version
  */
 
 class UniWRTCClient {
   constructor(serverUrl, options = {}) {
-    this.serverUrl = serverUrl;
+    // 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.sessionId = null;
-    this._pollTimer = null;
-
+    this.roomId = options.roomId || 'default';
+    this.peers = new Map();
+    this._connectedOnce = false;
     this.options = {
       autoReconnect: true,
       reconnectDelay: 3000,
-      pollIntervalMs: 500,
-      roomId: options.roomId || 'default',
       ...options
     };
-
     this.eventHandlers = {
       'connected': [],
       'disconnected': [],
@@ -32,158 +38,122 @@ class UniWRTCClient {
     };
   }
 
-  baseOrigin() {
-    const parsed = new URL(this.serverUrl);
-    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
-      throw new Error('Server URL must start with http(s):// (WebSockets are disabled)');
-    }
-    return parsed.origin;
-  }
-
-  apiUrl(pathname, extraSearch = {}) {
-    const origin = this.baseOrigin();
-    const url = new URL(origin + pathname);
-    url.searchParams.set('room', this.options.roomId);
-    for (const [k, v] of Object.entries(extraSearch)) {
-      if (v !== undefined && v !== null) url.searchParams.set(k, String(v));
-    }
-    return url.toString();
-  }
-
-  async postJson(pathname, body) {
-    const res = await fetch(this.apiUrl(pathname), {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(body)
-    });
-    const data = await res.json().catch(() => null);
-    if (!res.ok) {
-      const message = data?.message || `HTTP ${res.status}`;
-      throw new Error(message);
-    }
-    return data;
-  }
-
-  startPolling() {
-    if (this._pollTimer) return;
-    this._pollTimer = setInterval(() => {
-      this.pollOnce().catch((err) => {
-        this.emit('error', { message: err?.message || String(err) });
-      });
-    }, this.options.pollIntervalMs);
-  }
-
-  stopPolling() {
-    if (this._pollTimer) {
-      clearInterval(this._pollTimer);
-      this._pollTimer = null;
-    }
-  }
-
-  async connect() {
-    try {
-      const welcome = await this.postJson('/api/connect', {});
-      this.clientId = welcome.clientId;
-
-      if (this.options.customPeerId) {
-        const res = await this.postJson('/api/set-id', {
-          clientId: this.clientId,
-          customId: this.options.customPeerId
-        });
-        this.clientId = res.clientId;
-      }
+  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.emit('connected', { clientId: this.clientId });
-      this.startPolling();
-      return this.clientId;
-    } catch (error) {
-      this.emit('error', { message: error?.message || String(error) });
-      if (this.options.autoReconnect) {
-        setTimeout(() => this.connect(), this.options.reconnectDelay);
+        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);
       }
-      throw error;
-    }
+    });
   }
 
-  async disconnect() {
-    this.options.autoReconnect = false;
-    this.stopPolling();
-    if (this.clientId) {
-      try {
-        await this.postJson('/api/leave', { clientId: this.clientId });
-      } catch {
-        // ignore
-      }
+  disconnect() {
+    if (this.ws) {
+      this.options.autoReconnect = false;
+      this.ws.close();
+      this.ws = null;
     }
-    this.emit('disconnected');
   }
 
-  async joinSession(sessionId) {
-    if (!this.clientId) throw new Error('Not connected');
-    if (this.sessionId === sessionId) return;
+  joinSession(sessionId) {
     this.sessionId = sessionId;
-
-    const joined = await this.postJson('/api/join', {
-      clientId: this.clientId,
-      sessionId
-    });
-
-    this.emit('joined', {
-      sessionId: joined.sessionId,
-      clientId: joined.clientId,
-      clients: joined.clients
-    });
-  }
-
-  async leaveSession() {
-    this.sessionId = null;
+    // Durable Objects handle session joining automatically via room parameter
   }
 
-  async pollOnce() {
-    if (!this.clientId) return;
-    const url = this.apiUrl('/api/poll', { clientId: this.clientId });
-    const res = await fetch(url, { method: 'GET' });
-    const data = await res.json().catch(() => null);
-    if (!res.ok) {
-      throw new Error(data?.message || `HTTP ${res.status}`);
-    }
-
-    const messages = Array.isArray(data?.messages) ? data.messages : [];
-    for (const msg of messages) {
-      this.handleMessage(msg);
+  leaveSession() {
+    if (this.sessionId) {
+      this.sessionId = null;
     }
   }
 
-  async sendSignal(payload) {
-    if (!this.clientId) throw new Error('Not connected');
-    await this.postJson('/api/signal', {
-      clientId: this.clientId,
-      sessionId: this.sessionId,
-      ...payload
-    });
+  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) {
-    const offerSdp = typeof offer === 'string' ? offer : offer?.sdp;
-    return this.sendSignal({ type: 'offer', offer: offerSdp, targetId });
+    this.send({
+      type: 'offer',
+      offer: offer,
+      targetId: targetId
+    });
   }
 
   sendAnswer(answer, targetId) {
-    const answerSdp = typeof answer === 'string' ? answer : answer?.sdp;
-    return this.sendSignal({ type: 'answer', answer: answerSdp, targetId });
+    this.send({
+      type: 'answer',
+      answer: answer,
+      targetId: targetId
+    });
   }
 
   sendIceCandidate(candidate, targetId) {
-    const candidateText =
-      typeof candidate === 'string'
-        ? candidate
-        : candidate && typeof candidate === 'object' && typeof candidate.candidate === 'string'
-          ? `${candidate.candidate}|${candidate.sdpMid ?? ''}|${candidate.sdpMLineIndex ?? ''}`
-          : candidate;
-    return this.sendSignal({ type: 'ice-candidate', candidate: candidateText, targetId });
+    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');
   }
 
@@ -215,6 +185,7 @@ class UniWRTCClient {
     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.sessionId = message.sessionId;
@@ -254,15 +225,25 @@ class UniWRTCClient {
           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);
     }
   }
 }
-
-export default UniWRTCClient;

package/src/main.js

@@ -21,7 +21,7 @@ document.getElementById('app').innerHTML = `
             <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="https://signal.peer.ooo or http://localhost:8080" value="https://signal.peer.ooo">
+                    <input type="text" id="serverUrl" data-testid="serverUrl" placeholder="wss://signal.peer.ooo or ws://localhost:8080" value="wss://signal.peer.ooo">
                 </div>
                 <div>
                     <label style="display: block; margin-bottom: 5px; color: #64748b; font-size: 13px;">Room / Session ID</label>
@@ -146,43 +146,6 @@ function updatePeerList() {
     }
 }
 
-function normalizeSessionDescription(descOrSdp, fallbackType) {
-    if (!descOrSdp) {
-        throw new Error(`Missing ${fallbackType} SDP`);
-    }
-
-    if (typeof descOrSdp === 'string') {
-        return { type: fallbackType, sdp: descOrSdp };
-    }
-
-    if (typeof descOrSdp === 'object') {
-        if (typeof descOrSdp.sdp === 'string') {
-            return {
-                type: descOrSdp.type || fallbackType,
-                sdp: descOrSdp.sdp
-            };
-        }
-    }
-
-    return descOrSdp;
-}
-
-function normalizeIceCandidate(candidateOrText) {
-    if (!candidateOrText) return null;
-    if (typeof candidateOrText === 'string') {
-        const [candidate, sdpMidRaw, sdpMLineIndexRaw] = candidateOrText.split('|');
-        if (!candidate) return null;
-        const ice = { candidate };
-        if (sdpMidRaw) ice.sdpMid = sdpMidRaw;
-        if (sdpMLineIndexRaw !== undefined && sdpMLineIndexRaw !== '') {
-            const idx = Number(sdpMLineIndexRaw);
-            if (!Number.isNaN(idx)) ice.sdpMLineIndex = idx;
-        }
-        return ice;
-    }
-    return candidateOrText;
-}
-
 window.connect = async function() {
     const serverUrl = document.getElementById('serverUrl').value.trim();
     const roomId = document.getElementById('roomId').value.trim();
@@ -199,15 +162,15 @@ window.connect = async function() {
 
     try {
             log(`Connecting to ${serverUrl}...`, 'info');
-
-        const isHttpUrl = /^https?:\/\//i.test(serverUrl);
-        if (!isHttpUrl) {
-            throw new Error('Server URL must start with http(s):// (WebSockets are disabled)');
+        
+        // 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');
         }
-
-        // HTTP polling signaling (no WebSockets)
-        client = new UniWRTCClient(serverUrl, { autoReconnect: false, roomId });
-        log(`Using HTTP polling (no WebSockets) for room: ${roomId}`, 'info');
+        
+        client = new UniWRTCClient(finalUrl, { autoReconnect: false });
         
         client.on('connected', (data) => {
                 log(`Connected with client ID: ${data.clientId}`, 'success');
@@ -261,7 +224,7 @@ window.connect = async function() {
         client.on('offer', async (data) => {
                 log(`Received offer from ${data.peerId.substring(0, 6)}...`, 'info');
             const pc = peerConnections.get(data.peerId) || await createPeerConnection(data.peerId, false);
-            await pc.setRemoteDescription(normalizeSessionDescription(data.offer, 'offer'));
+            await pc.setRemoteDescription(new RTCSessionDescription(data.offer));
             const answer = await pc.createAnswer();
             await pc.setLocalDescription(answer);
             client.sendAnswer(answer, data.peerId);
@@ -272,7 +235,7 @@ window.connect = async function() {
                 log(`Received answer from ${data.peerId.substring(0, 6)}...`, 'info');
             const pc = peerConnections.get(data.peerId);
             if (pc) {
-                await pc.setRemoteDescription(normalizeSessionDescription(data.answer, 'answer'));
+                await pc.setRemoteDescription(new RTCSessionDescription(data.answer));
             }
         });
 
@@ -280,10 +243,7 @@ window.connect = async function() {
                 log(`Received ICE candidate from ${data.peerId.substring(0, 6)}...`, 'info');
             const pc = peerConnections.get(data.peerId);
             if (pc && data.candidate) {
-                const iceInit = normalizeIceCandidate(data.candidate);
-                if (iceInit) {
-                    await pc.addIceCandidate(new RTCIceCandidate(iceInit));
-                }
+                await pc.addIceCandidate(new RTCIceCandidate(data.candidate));
             }
         });
 
@@ -329,9 +289,9 @@ async function createPeerConnection(peerId, shouldInitiate) {
         log(`Creating peer connection with ${peerId.substring(0, 6)}... (shouldInitiate: ${shouldInitiate})`, 'info');
 
     const pc = new RTCPeerConnection({
-        // Avoid external STUN for reliability in restricted environments.
-        // Host candidates are sufficient for same-device/browser-tab testing.
-        iceServers: []
+        iceServers: [
+            { urls: ['stun:stun.l.google.com:19302', 'stun:stun1.l.google.com:19302'] }
+        ]
     });
 
     pc.onicecandidate = (event) => {

package/simple-peer-adapter.js

@@ -1,124 +0,0 @@
-/**
- * simple-peer ↔ UniWRTC signaling adapter (SDP text only)
- *
- * UniWRTC wire format after this repo's change:
- * - offer: { type: 'offer', offer: '<sdp string>', targetId, sessionId? }
- * - answer:{ type: 'answer', answer:'<sdp string>', targetId, sessionId? }
- * - ice:   { type: 'ice-candidate', candidate: RTCIceCandidateInit, targetId, sessionId? }
- *
- * This adapter maps simple-peer "signal" objects to/from that wire format.
- */
-
-function normalizeSdp(value) {
-  if (!value) return null;
-  if (typeof value === 'string') return value;
-  if (typeof value === 'object' && typeof value.sdp === 'string') return value.sdp;
-  return null;
-}
-
-function isIceCandidateSignal(signal) {
-  return !!signal && typeof signal === 'object' && typeof signal.candidate === 'string';
-}
-
-function parseIceCandidateText(candidateText) {
-  if (!candidateText || typeof candidateText !== 'string') return null;
-  const [candidate, sdpMidRaw, sdpMLineIndexRaw] = candidateText.split('|');
-  if (!candidate) return null;
-  const ice = { candidate };
-  if (sdpMidRaw) ice.sdpMid = sdpMidRaw;
-  if (sdpMLineIndexRaw !== undefined && sdpMLineIndexRaw !== '') {
-    const idx = Number(sdpMLineIndexRaw);
-    if (!Number.isNaN(idx)) ice.sdpMLineIndex = idx;
-  }
-  return ice;
-}
-
-/**
- * Deterministically chooses a single initiator for a given peer pair.
- * Returns true for exactly one side when both sides use the same two IDs.
- */
-export function chooseDeterministicInitiator(localPeerId, remotePeerId) {
-  if (!localPeerId || !remotePeerId) {
-    throw new Error('localPeerId and remotePeerId are required');
-  }
-  return String(localPeerId) < String(remotePeerId);
-}
-
-/**
- * Sends a simple-peer signal via UniWRTCClient.
- *
- * @param {object} client UniWRTCClient instance
- * @param {object} signal simple-peer signal object
- * @param {string} targetId peer id to target
- */
-export function sendSimplePeerSignal(client, signal, targetId) {
-  if (!client) throw new Error('client is required');
-  if (!signal) throw new Error('signal is required');
-  if (!targetId) throw new Error('targetId is required');
-
-  if (signal.type === 'offer') {
-    const sdp = normalizeSdp(signal.sdp ?? signal);
-    if (!sdp) throw new Error('offer SDP missing');
-    client.sendOffer(sdp, targetId);
-    return;
-  }
-
-  if (signal.type === 'answer') {
-    const sdp = normalizeSdp(signal.sdp ?? signal);
-    if (!sdp) throw new Error('answer SDP missing');
-    client.sendAnswer(sdp, targetId);
-    return;
-  }
-
-  // simple-peer ICE candidate signal has shape: { candidate, sdpMid, sdpMLineIndex }
-  if (isIceCandidateSignal(signal) || signal.type === 'ice-candidate' || signal.type === 'candidate') {
-    client.sendIceCandidate(signal, targetId);
-    return;
-  }
-
-  // simple-peer can emit renegotiation / transceiver requests.
-  // UniWRTC server in this repo doesn't route arbitrary signal types.
-  throw new Error(`Unsupported simple-peer signal type for UniWRTC transport: ${signal.type || '(unknown)'}`);
-}
-
-/**
- * Attaches UniWRTCClient events to a simple-peer instance.
- *
- * @param {object} client UniWRTCClient instance
- * @param {object} peer simple-peer instance (must have peer.signal())
- * @returns {() => void} cleanup function
- */
-export function attachUniWRTCToSimplePeer(client, peer) {
-  if (!client) throw new Error('client is required');
-  if (!peer || typeof peer.signal !== 'function') throw new Error('peer.signal(...) is required');
-
-  const onOffer = (data) => {
-    const sdp = normalizeSdp(data.offer);
-    if (sdp) peer.signal({ type: 'offer', sdp });
-  };
-
-  const onAnswer = (data) => {
-    const sdp = normalizeSdp(data.answer);
-    if (sdp) peer.signal({ type: 'answer', sdp });
-  };
-
-  const onIce = (data) => {
-    if (!data?.candidate) return;
-    if (typeof data.candidate === 'string') {
-      const ice = parseIceCandidateText(data.candidate);
-      if (ice) peer.signal(ice);
-      return;
-    }
-    peer.signal(data.candidate);
-  };
-
-  client.on('offer', onOffer);
-  client.on('answer', onAnswer);
-  client.on('ice-candidate', onIce);
-
-  return () => {
-    client.off('offer', onOffer);
-    client.off('answer', onAnswer);
-    client.off('ice-candidate', onIce);
-  };
-}