uniwrtc 1.0.0

package/.env.example

@@ -0,0 +1,8 @@
+# UniWRTC Configuration Example
+# Copy this file to .env and customize as needed
+
+# Server port (default: 8080)
+PORT=8080
+
+# Optional: Enable debug logging
+# DEBUG=true

package/CLOUDFLARE_DEPLOYMENT.md

@@ -0,0 +1,127 @@
+# UniWRTC Cloudflare Deployment Guide
+
+## Prerequisites
+
+1. **Cloudflare Account** - Free tier is sufficient
+2. **Wrangler CLI** - Install: `npm install -g wrangler`
+3. **Node.js** - v16 or higher
+4. **Your Domain** - Domain must be on Cloudflare (e.g., `peer.ooo`)
+
+## Setup Steps
+
+### 1. Install Wrangler
+
+```bash
+npm install -g wrangler
+```
+
+### 2. Authenticate with Cloudflare
+
+```bash
+wrangler login
+```
+
+This will open your browser to authorize the CLI.
+
+### 3. Update wrangler.toml
+
+Replace the zone configuration with your domain:
+
+```toml
+[env.production]
+routes = [
+  { pattern = "signal.peer.ooo/*", zone_name = "peer.ooo" }
+]
+```
+
+### 4. Deploy to Cloudflare
+
+```bash
+# Deploy to production
+wrangler publish --env production
+
+# Or deploy to staging first
+wrangler publish
+```
+
+### 5. Access Your Signaling Server
+
+Your server will be available at:
+- **Production**: `https://signal.peer.ooo/`
+- **Development**: `https://uniwrtc.<subdomain>.workers.dev/`
+
+## Using with UniWRTC Demo
+
+Update the demo to use your Cloudflare endpoint:
+
+```javascript
+// In demo.html or client
+const serverUrl = 'https://signal.peer.ooo/';
+const roomId = 'my-room';
+
+const client = new UniWRTCClient(serverUrl, { 
+  roomId: roomId,
+  customPeerId: 'optional-id' 
+});
+
+await client.connect();
+```
+
+## How It Works
+
+1. **Durable Objects** - One per room, manages peer discovery
+2. **WebSocket** - 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
+
+## Cost
+
+- **Requests**: 100,000 free per day (signaling only)
+- **Compute**: Included in free tier
+- **Durable Objects**: ~$0.15/million operations (minimal for signaling)
+- **Total**: Free to very low cost
+
+## Monitoring
+
+Check deployment status:
+
+```bash
+wrangler tail --env production
+```
+
+View real-time logs from your Worker.
+
+## Local Development
+
+Test locally before deploying:
+
+```bash
+wrangler dev
+```
+
+Your local server will run at `http://localhost:8787`
+
+Update demo to test:
+```javascript
+const serverUrl = 'http://localhost:8787/';
+```
+
+## Troubleshooting
+
+**WebSocket errors**: Ensure your domain is on Cloudflare with SSL enabled
+
+**Connection refused**: Check the Worker route pattern in `wrangler.toml`
+
+**Durable Objects not found**: Run `wrangler publish` with migrations enabled
+
+## Next Steps
+
+1. Deploy the Worker
+2. Update demo.html to use your Cloudflare endpoint
+3. Test with multiple browsers
+4. Scale up!
+
+---
+
+For more info: [Cloudflare Workers Docs](https://developers.cloudflare.com/workers/)

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Daniel Raeder
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/QUICKSTART_CLOUDFLARE.md

@@ -0,0 +1,55 @@
+# Quick Start - Deploy to Cloudflare in 30 seconds
+
+## Prerequisites
+- Cloudflare account (free tier works)
+- Your domain on Cloudflare
+- Node.js installed
+
+## Deploy
+
+### macOS / Linux
+```bash
+chmod +x deploy-cloudflare.sh
+./deploy-cloudflare.sh
+```
+
+### Windows
+```bash
+deploy-cloudflare.bat
+```
+
+## What the script does:
+1. ✅ Checks Node.js and installs Wrangler
+2. ✅ Authenticates with Cloudflare
+3. ✅ Asks for your domain (e.g., `signal.peer.ooo`)
+4. ✅ Updates `wrangler.toml`
+5. ✅ Deploys to Cloudflare Workers
+6. ✅ Gives you the live URL
+
+## After deployment:
+
+Update demo.html:
+```javascript
+const serverUrl = 'https://signal.peer.ooo/'; // Your domain
+```
+
+Then reload the demo and it will connect to your Cloudflare Workers signaling server! 🚀
+
+## Testing
+
+Test the server:
+```bash
+curl https://signal.peer.ooo/health
+```
+
+View logs:
+```bash
+wrangler tail --env production
+```
+
+Local development:
+```bash
+wrangler dev
+```
+
+That's it! Your WebRTC signaling is now on Cloudflare! 🎉

package/README.md

@@ -0,0 +1,384 @@
+# UniWRTC
+
+A universal WebRTC signaling service that provides a simple and flexible WebSocket-based signaling server for WebRTC applications.
+
+## Features
+
+- 🚀 **Simple WebSocket-based signaling** - Easy to integrate with any WebRTC application
+- 🏠 **Room-based architecture** - Support for multiple rooms 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
+
+## Quick Start
+
+### Installation
+
+1. Clone the repository:
+```bash
+git clone https://github.com/draeder/UniWRTC.git
+cd UniWRTC
+```
+
+2. Install dependencies:
+```bash
+npm install
+```
+
+3. Start the server:
+```bash
+npm start
+```
+
+The signaling server will start on port 8080 by default.
+
+### Environment Configuration
+
+Create a `.env` file based on `.env.example`:
+
+```bash
+cp .env.example .env
+```
+
+Configure the port:
+```
+PORT=8080
+```
+
+### Try the Demo
+
+Open `demo.html` in your web browser to try the interactive demo:
+
+1. Start the server with `npm start` (local signaling at `ws://localhost:8080`), **or** use the deployed Workers endpoint `wss://signal.peer.ooo`.
+2. Open `demo.html` in your browser.
+3. Click "Connect" to connect to the signaling server.
+4. Enter a room ID and click "Join Room".
+5. Open another browser window/tab with the same demo page.
+6. Join the same room to see peer connections in action and P2P data channels open.
+
+## Usage
+
+### Server API
+
+The signaling server accepts WebSocket connections and supports the following message types:
+
+#### Client → Server Messages
+
+**Join a room:**
+```json
+{
+  "type": "join",
+  "roomId": "room-123"
+}
+```
+
+**Leave a room:**
+```json
+{
+  "type": "leave",
+  "roomId": "room-123"
+}
+```
+
+**Send WebRTC offer:**
+```json
+{
+  "type": "offer",
+  "offer": { /* RTCSessionDescription */ },
+  "targetId": "peer-client-id",
+  "roomId": "room-123"
+}
+```
+
+**Send WebRTC answer:**
+```json
+{
+  "type": "answer",
+  "answer": { /* RTCSessionDescription */ },
+  "targetId": "peer-client-id",
+  "roomId": "room-123"
+}
+```
+
+**Send ICE candidate:**
+```json
+{
+  "type": "ice-candidate",
+  "candidate": { /* RTCIceCandidate */ },
+  "targetId": "peer-client-id",
+  "roomId": "room-123"
+}
+```
+
+**List available rooms:**
+```json
+{
+  "type": "list-rooms"
+}
+```
+
+#### Server → Client Messages
+
+**Welcome message (on connection):**
+```json
+{
+  "type": "welcome",
+  "clientId": "abc123",
+  "message": "Connected to UniWRTC signaling server"
+}
+```
+
+**Room joined confirmation:**
+```json
+{
+  "type": "joined",
+  "roomId": "room-123",
+  "clientId": "abc123",
+  "clients": ["xyz789", "def456"]
+}
+```
+
+**Peer joined notification:**
+```json
+{
+  "type": "peer-joined",
+  "peerId": "new-peer-id",
+  "clientId": "new-peer-id"
+}
+```
+
+**Peer left notification:**
+```json
+{
+  "type": "peer-left",
+  "peerId": "departed-peer-id",
+  "clientId": "departed-peer-id"
+}
+```
+
+### Client Library Usage
+
+The `client.js` library provides a convenient wrapper for the signaling protocol:
+
+```javascript
+// Create a client instance
+const client = new UniWRTCClient('ws://localhost:8080');
+
+// Set up event handlers
+client.on('connected', (data) => {
+  console.log('Connected with ID:', data.clientId);
+});
+
+client.on('joined', (data) => {
+  console.log('Joined room:', data.roomId);
+  console.log('Existing peers:', data.clients);
+});
+
+client.on('peer-joined', (data) => {
+  console.log('New peer joined:', data.peerId || data.clientId);
+  // Initiate WebRTC connection with new peer
+});
+
+client.on('offer', (data) => {
+  console.log('Received offer from:', data.peerId || data.senderId);
+  // Handle WebRTC offer
+});
+
+client.on('answer', (data) => {
+  console.log('Received answer from:', data.peerId || data.senderId);
+  // Handle WebRTC answer
+});
+
+client.on('ice-candidate', (data) => {
+  console.log('Received ICE candidate from:', data.peerId || data.senderId);
+  // Add ICE candidate to peer connection
+});
+
+// Connect to the server
+await client.connect();
+
+// Join a room
+client.joinRoom('my-room');
+
+// Send WebRTC signaling messages
+client.sendOffer(offerObject, targetPeerId);
+client.sendAnswer(answerObject, targetPeerId);
+client.sendIceCandidate(candidateObject, targetPeerId);
+```
+
+### Integration Example
+
+Here's a complete example of creating a WebRTC peer connection:
+
+```javascript
+const client = new UniWRTCClient('ws://localhost:8080');
+const peerConnections = new Map();
+
+// ICE server configuration
+const configuration = {
+  iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
+};
+
+// Create peer connection
+function createPeerConnection(peerId) {
+  const pc = new RTCPeerConnection(configuration);
+  
+  pc.onicecandidate = (event) => {
+    if (event.candidate) {
+      client.sendIceCandidate(event.candidate, peerId);
+    }
+  };
+  
+  pc.ontrack = (event) => {
+    // Handle incoming media stream
+    console.log('Received remote track');
+  };
+  
+  peerConnections.set(peerId, pc);
+  return pc;
+}
+
+// Handle new peer
+client.on('peer-joined', async (data) => {
+  const pc = createPeerConnection(data.clientId);
+  
+  // Add local tracks
+  const stream = await navigator.mediaDevices.getUserMedia({ 
+    video: true, 
+    audio: true 
+  });
+  stream.getTracks().forEach(track => pc.addTrack(track, stream));
+  
+  // Create and send offer
+  const offer = await pc.createOffer();
+  await pc.setLocalDescription(offer);
+  client.sendOffer(offer, data.clientId);
+});
+
+// Handle incoming offer
+client.on('offer', async (data) => {
+  const pc = createPeerConnection(data.senderId);
+  
+  await pc.setRemoteDescription(data.offer);
+  const answer = await pc.createAnswer();
+  await pc.setLocalDescription(answer);
+  client.sendAnswer(answer, data.senderId);
+});
+
+// Handle incoming answer
+client.on('answer', async (data) => {
+  const pc = peerConnections.get(data.senderId);
+  if (pc) {
+    await pc.setRemoteDescription(data.answer);
+  }
+});
+
+// Handle ICE candidates
+client.on('ice-candidate', async (data) => {
+  const pc = peerConnections.get(data.senderId);
+  if (pc) {
+    await pc.addIceCandidate(data.candidate);
+  }
+});
+
+// Connect and join room
+await client.connect();
+client.joinRoom('my-video-room');
+```
+
+## API Reference
+
+### UniWRTCClient
+
+#### Constructor
+```javascript
+new UniWRTCClient(serverUrl, options)
+```
+
+**Parameters:**
+- `serverUrl` (string): WebSocket 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)
+
+#### Methods
+
+- `connect()`: Connect to the signaling server (returns Promise)
+- `disconnect()`: Disconnect from the server
+- `joinRoom(roomId)`: Join a specific room
+- `leaveRoom()`: Leave the current room
+- `sendOffer(offer, targetId)`: Send a WebRTC offer
+- `sendAnswer(answer, targetId)`: Send a WebRTC answer
+- `sendIceCandidate(candidate, targetId)`: Send an ICE candidate
+- `listRooms()`: Request list of available rooms
+- `on(event, handler)`: Register event handler
+- `off(event, handler)`: Unregister event handler
+
+#### Events
+
+- `connected`: Fired when connected to the server
+- `disconnected`: Fired when disconnected from the server
+- `joined`: Fired when successfully joined a room
+- `peer-joined`: Fired when another peer joins the room
+- `peer-left`: Fired when a peer leaves the room
+- `offer`: Fired when receiving a WebRTC offer
+- `answer`: Fired when receiving a WebRTC answer
+- `ice-candidate`: Fired when receiving an ICE candidate
+- `room-list`: Fired when receiving the list of rooms
+- `error`: Fired on error
+
+## Health Check
+
+The server provides an HTTP health check endpoint:
+
+```bash
+curl http://localhost:8080/health
+```
+
+Response:
+```json
+{
+  "status": "ok",
+  "connections": 5
+}
+```
+
+## Architecture
+
+### Room Management
+
+- Each room is identified by a unique room ID (string)
+- Clients can join/leave rooms dynamically
+- Messages can be sent to specific peers or broadcast to all peers in a room
+- Empty rooms are automatically cleaned up
+
+### Message Flow
+
+1. Client connects via WebSocket
+2. Server assigns a unique client ID
+3. Client joins a room
+4. Server notifies existing peers about the new client
+5. Peers exchange WebRTC signaling messages through the server
+6. Server routes messages based on target ID or broadcasts to room
+
+## 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
+- Adding room access controls
+- Implementing message validation
+- Monitoring and logging
+- Setting up CORS policies
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.