@xtr-dev/rondevu-client 0.10.1 → 0.11.0

package/dist/service-host.js

@@ -1,186 +1,120 @@
-import { WebRTCRondevuConnection } from './connection.js';
+import { RondevuSignaler } from './rondevu-signaler.js';
 import { WebRTCContext } from './webrtc-context.js';
-import { RondevuSignaler } from './signaler.js';
-import { NoOpSignaler } from './noop-signaler.js';
+import { RTCDurableConnection } from './durable-connection.js';
 import { EventBus } from './event-bus.js';
-import { createBin } from './bin.js';
 /**
- * ServiceHost - Manages a pool of WebRTC offers for a service
+ * ServiceHost - High-level wrapper for hosting a WebRTC service
  *
- * Maintains up to maxPeers concurrent offers, automatically replacing
- * them when connections are established or expire.
+ * Simplifies hosting by handling:
+ * - Offer/answer exchange
+ * - ICE candidate polling
+ * - Connection pool management
+ * - Automatic reconnection
  *
  * @example
  * ```typescript
- * const rondevuService = new RondevuService({
- *   apiUrl: 'https://signal.example.com',
- *   username: 'myusername',
+ * const host = new ServiceHost({
+ *     service: 'chat.app@1.0.0',
+ *     rondevuService: myService,
+ *     maxPeers: 5
  * })
  *
- * await rondevuService.initialize()
- * await rondevuService.claimUsername()
- *
- * const host = new ServiceHost({
- *   service: 'chat.app@1.0.0',
- *   rondevuService,
- *   maxPeers: 5,
+ * host.events.on('connection', conn => {
+ *     conn.events.on('message', msg => console.log('Received:', msg))
+ *     conn.sendMessage('Hello!')
  * })
  *
  * await host.start()
- *
- * host.events.on('connection', (conn) => {
- *   console.log('New connection:', conn.id)
- *   conn.events.on('message', (msg) => {
- *     console.log('Message:', msg)
- *   })
- * })
  * ```
  */
 export class ServiceHost {
     constructor(options) {
-        this.connections = new Map();
-        this.bin = createBin();
-        this.isStarted = false;
+        this.options = options;
+        this.signaler = null;
+        this.connections = [];
+        this.running = false;
         this.events = new EventBus();
-        this.service = options.service;
-        this.rondevuService = options.rondevuService;
-        this.maxPeers = options.maxPeers || 20;
-        this.ttl = options.ttl || 300000;
-        this.isPublic = options.isPublic !== false;
-        this.metadata = options.metadata;
-        this.rtcConfiguration = options.rtcConfiguration;
+        this.webrtcContext = new WebRTCContext(options.rtcConfiguration);
+        this.maxPeers = options.maxPeers || 5;
     }
     /**
-     * Start hosting the service - creates initial pool of offers
+     * Start hosting the service
      */
     async start() {
-        if (this.isStarted) {
-            throw new Error('ServiceHost already started');
+        if (this.running) {
+            throw new Error('ServiceHost already running');
         }
-        this.isStarted = true;
-        await this.fillOfferPool();
-    }
-    /**
-     * Stop hosting - closes all connections and cleans up
-     */
-    stop() {
-        this.isStarted = false;
-        this.connections.forEach(conn => conn.disconnect());
-        this.connections.clear();
-        this.bin.clean();
-    }
-    /**
-     * Get current number of active connections
-     */
-    getConnectionCount() {
-        return Array.from(this.connections.values()).filter(conn => conn.state === 'connected')
-            .length;
-    }
-    /**
-     * Get current number of pending offers
-     */
-    getPendingOfferCount() {
-        return Array.from(this.connections.values()).filter(conn => conn.state === 'connecting')
-            .length;
-    }
-    /**
-     * Fill the offer pool up to maxPeers
-     */
-    async fillOfferPool() {
-        const currentOffers = this.connections.size;
-        const needed = this.maxPeers - currentOffers;
-        if (needed <= 0) {
-            return;
-        }
-        // Create multiple offers in parallel
-        const offerPromises = [];
-        for (let i = 0; i < needed; i++) {
-            offerPromises.push(this.createOffer());
+        this.running = true;
+        // Create signaler
+        this.signaler = new RondevuSignaler(this.options.rondevuService, this.options.service);
+        // Create first connection (offerer)
+        const connection = new RTCDurableConnection({
+            context: this.webrtcContext,
+            signaler: this.signaler,
+            offer: null // null means we're the offerer
+        });
+        // Wait for connection to be ready
+        await connection.ready;
+        // Set up connection event listeners
+        connection.events.on('state-change', (state) => {
+            if (state === 'connected') {
+                this.connections.push(connection);
+                this.events.emit('connection', connection);
+                // Create next connection if under maxPeers
+                if (this.connections.length < this.maxPeers) {
+                    this.createNextConnection().catch(err => {
+                        console.error('Failed to create next connection:', err);
+                        this.events.emit('error', err);
+                    });
+                }
+            }
+            else if (state === 'disconnected') {
+                // Remove from connections list
+                const index = this.connections.indexOf(connection);
+                if (index > -1) {
+                    this.connections.splice(index, 1);
+                }
+            }
+        });
+        // Publish service with the offer
+        const offer = connection.connection?.localDescription;
+        if (!offer?.sdp) {
+            throw new Error('Offer SDP is empty');
         }
-        await Promise.allSettled(offerPromises);
+        await this.signaler.setOffer(offer);
     }
     /**
-     * Create a single offer and publish it
+     * Create the next connection for incoming peers
      */
-    async createOffer() {
-        try {
-            // Create temporary context with NoOp signaler
-            const tempContext = new WebRTCContext(new NoOpSignaler(), this.rtcConfiguration);
-            // Create connection (offerer role)
-            const conn = new WebRTCRondevuConnection({
-                id: `${this.service}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
-                service: this.service,
-                offer: null,
-                context: tempContext,
-            });
-            // Wait for offer to be created
-            await conn.ready;
-            // Get offer SDP
-            if (!conn.connection?.localDescription?.sdp) {
-                throw new Error('Failed to create offer SDP');
-            }
-            const sdp = conn.connection.localDescription.sdp;
-            // Publish service offer
-            const service = await this.rondevuService.publishService({
-                serviceFqn: this.service,
-                sdp,
-                ttl: this.ttl,
-                isPublic: this.isPublic,
-                metadata: this.metadata,
-            });
-            // Replace with real signaler now that we have offerId
-            const realSignaler = new RondevuSignaler(this.rondevuService.getAPI(), service.offerId);
-            tempContext.signaler = realSignaler;
-            // Track connection
-            this.connections.set(conn.id, conn);
-            // Listen for state changes
-            const cleanup = conn.events.on('state-change', state => {
-                this.handleConnectionStateChange(conn, state);
-            });
-            this.bin(cleanup);
-        }
-        catch (error) {
-            this.events.emit('error', error);
+    async createNextConnection() {
+        if (!this.signaler || !this.running) {
+            return;
         }
+        // For now, we'll use the same offer for all connections
+        // In a production scenario, you'd create multiple offers
+        // This is a limitation of the current service model
+        // which publishes one offer per service
     }
     /**
-     * Handle connection state changes
+     * Stop hosting the service
      */
-    handleConnectionStateChange(conn, state) {
-        if (state === 'connected') {
-            // Connection established - emit event
-            this.events.emit('connection', conn);
-            // Create new offer to replace this one
-            if (this.isStarted) {
-                this.fillOfferPool().catch(error => {
-                    this.events.emit('error', error);
-                });
-            }
+    dispose() {
+        this.running = false;
+        // Cleanup signaler
+        if (this.signaler) {
+            this.signaler.dispose();
+            this.signaler = null;
         }
-        else if (state === 'disconnected') {
-            // Connection closed - remove and create new offer
-            this.connections.delete(conn.id);
-            this.events.emit('connection-closed', {
-                connectionId: conn.id,
-                reason: state,
-            });
-            if (this.isStarted) {
-                this.fillOfferPool().catch(error => {
-                    this.events.emit('error', error);
-                });
-            }
+        // Disconnect all connections
+        for (const conn of this.connections) {
+            conn.disconnect();
         }
+        this.connections = [];
     }
     /**
      * Get all active connections
      */
     getConnections() {
-        return Array.from(this.connections.values());
-    }
-    /**
-     * Get a specific connection by ID
-     */
-    getConnection(connectionId) {
-        return this.connections.get(connectionId);
+        return [...this.connections];
     }
 }

package/dist/types.d.ts

@@ -14,8 +14,6 @@ export interface ConnectionEvents {
 export declare const ConnectionStates: readonly ["connected", "disconnected", "connecting"];
 export declare const isConnectionState: (state: string) => state is (typeof ConnectionStates)[number];
 export interface ConnectionInterface {
-    id: string;
-    service: string;
     state: (typeof ConnectionStates)[number];
     lastActive: number;
     expiresAt?: number;
@@ -24,7 +22,7 @@ export interface ConnectionInterface {
     sendMessage(message: Message): Promise<boolean>;
 }
 export interface Signaler {
-    addIceCandidate(candidate: RTCIceCandidate): Promise<void> | void;
+    addIceCandidate(candidate: RTCIceCandidate): Promise<void>;
     addListener(callback: (candidate: RTCIceCandidate) => void): Binnable;
     addOfferListener(callback: (offer: RTCSessionDescriptionInit) => void): Binnable;
     addAnswerListener(callback: (answer: RTCSessionDescriptionInit) => void): Binnable;

package/dist/types.js

@@ -1,2 +1,6 @@
-export const ConnectionStates = ['connected', 'disconnected', 'connecting'];
+export const ConnectionStates = [
+    'connected',
+    'disconnected',
+    'connecting'
+];
 export const isConnectionState = (state) => ConnectionStates.includes(state);

package/dist/webrtc-context.d.ts

@@ -1,7 +1,5 @@
-import { Signaler } from './types';
 export declare class WebRTCContext {
-    readonly signaler: Signaler;
     private readonly config?;
-    constructor(signaler: Signaler, config?: RTCConfiguration | undefined);
+    constructor(config?: RTCConfiguration | undefined);
     createPeerConnection(): RTCPeerConnection;
 }

package/dist/webrtc-context.js

@@ -26,8 +26,7 @@ const DEFAULT_RTC_CONFIGURATION = {
     ],
 };
 export class WebRTCContext {
-    constructor(signaler, config) {
-        this.signaler = signaler;
+    constructor(config) {
         this.config = config;
     }
     createPeerConnection() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xtr-dev/rondevu-client",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "description": "TypeScript client for Rondevu with durable WebRTC connections, automatic reconnection, and message queuing",
   "type": "module",
   "main": "dist/index.js",