@xtr-dev/rondevu-client 0.10.1 → 0.10.2

package/dist/service-client.js

@@ -1,116 +1,96 @@
-import { WebRTCRondevuConnection } from './connection.js';
+import { RondevuSignaler } from './rondevu-signaler.js';
 import { WebRTCContext } from './webrtc-context.js';
-import { RondevuSignaler } from './signaler.js';
+import { RTCDurableConnection } from './durable-connection.js';
 import { EventBus } from './event-bus.js';
-import { createBin } from './bin.js';
 /**
- * ServiceClient - Connects to a hosted service
+ * ServiceClient - High-level wrapper for connecting to a WebRTC service
  *
- * Searches for available service offers and establishes a WebRTC connection.
- * Optionally supports automatic reconnection on failure.
+ * Simplifies client connection by handling:
+ * - Service discovery
+ * - Offer/answer exchange
+ * - ICE candidate polling
+ * - Automatic reconnection
  *
  * @example
  * ```typescript
- * const rondevuService = new RondevuService({
- *   apiUrl: 'https://signal.example.com',
- *   username: 'client-user',
+ * const client = new ServiceClient({
+ *     username: 'host-user',
+ *     serviceFqn: 'chat.app@1.0.0',
+ *     rondevuService: myService
  * })
  *
- * await rondevuService.initialize()
- *
- * const client = new ServiceClient({
- *   username: 'host-user',
- *   serviceFqn: 'chat.app@1.0.0',
- *   rondevuService,
- *   autoReconnect: true,
+ * client.events.on('connected', conn => {
+ *     conn.events.on('message', msg => console.log('Received:', msg))
+ *     conn.sendMessage('Hello from client!')
  * })
  *
  * await client.connect()
- *
- * client.events.on('connected', (conn) => {
- *   console.log('Connected to service')
- *   conn.sendMessage('Hello!')
- * })
  * ```
  */
 export class ServiceClient {
     constructor(options) {
+        this.options = options;
+        this.signaler = null;
         this.connection = null;
         this.reconnectAttempts = 0;
-        this.reconnectTimeout = null;
-        this.bin = createBin();
         this.isConnecting = false;
         this.events = new EventBus();
-        this.username = options.username;
-        this.serviceFqn = options.serviceFqn;
-        this.rondevuService = options.rondevuService;
-        this.autoReconnect = options.autoReconnect !== false;
-        this.reconnectDelay = options.reconnectDelay || 2000;
+        this.webrtcContext = new WebRTCContext(options.rtcConfiguration);
+        this.autoReconnect = options.autoReconnect !== undefined ? options.autoReconnect : true;
         this.maxReconnectAttempts = options.maxReconnectAttempts || 5;
-        this.rtcConfiguration = options.rtcConfiguration;
     }
     /**
      * Connect to the service
      */
     async connect() {
         if (this.isConnecting) {
-            throw new Error('Already connecting');
+            throw new Error('Connection already in progress');
         }
-        if (this.connection && this.connection.state === 'connected') {
-            return this.connection;
+        if (this.connection) {
+            throw new Error('Already connected. Disconnect first.');
         }
         this.isConnecting = true;
         try {
-            // Search for available services
-            const services = await this.rondevuService
-                .getAPI()
-                .searchServices(this.username, this.serviceFqn);
-            if (services.length === 0) {
-                throw new Error(`No services found for ${this.username}/${this.serviceFqn}`);
-            }
-            // Get the first available service
-            const service = services[0];
-            // Get service details including SDP
-            const serviceDetails = await this.rondevuService.getAPI().getService(service.uuid);
-            // Create WebRTC context with signaler for this offer
-            const signaler = new RondevuSignaler(this.rondevuService.getAPI(), serviceDetails.offerId);
-            const context = new WebRTCContext(signaler, this.rtcConfiguration);
-            // Create connection (answerer role)
-            const conn = new WebRTCRondevuConnection({
-                id: `client-${this.serviceFqn}-${Date.now()}`,
-                service: this.serviceFqn,
-                offer: {
-                    type: 'offer',
-                    sdp: serviceDetails.sdp,
-                },
-                context,
+            // Create signaler
+            this.signaler = new RondevuSignaler(this.options.rondevuService, this.options.serviceFqn, this.options.username);
+            // Wait for remote offer from signaler
+            const remoteOffer = await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    reject(new Error('Service discovery timeout'));
+                }, 30000);
+                this.signaler.addOfferListener((offer) => {
+                    clearTimeout(timeout);
+                    resolve(offer);
+                });
             });
-            // Wait for answer to be created
-            await conn.ready;
-            // Get answer SDP
-            if (!conn.connection?.localDescription?.sdp) {
-                throw new Error('Failed to create answer SDP');
-            }
-            const answerSdp = conn.connection.localDescription.sdp;
-            // Send answer to server
-            await this.rondevuService.getAPI().answerOffer(serviceDetails.offerId, answerSdp);
-            // Track connection
-            this.connection = conn;
-            this.reconnectAttempts = 0;
-            // Listen for state changes
-            const cleanup = conn.events.on('state-change', state => {
-                this.handleConnectionStateChange(state);
+            // Create connection with remote offer (makes us the answerer)
+            const connection = new RTCDurableConnection({
+                context: this.webrtcContext,
+                signaler: this.signaler,
+                offer: remoteOffer
+            });
+            // Wait for connection to be ready
+            await connection.ready;
+            // Set up connection event listeners
+            connection.events.on('state-change', (state) => {
+                if (state === 'connected') {
+                    this.reconnectAttempts = 0;
+                    this.events.emit('connected', connection);
+                }
+                else if (state === 'disconnected') {
+                    this.events.emit('disconnected', undefined);
+                    if (this.autoReconnect && this.reconnectAttempts < this.maxReconnectAttempts) {
+                        this.attemptReconnect();
+                    }
+                }
             });
-            this.bin(cleanup);
+            this.connection = connection;
             this.isConnecting = false;
-            // Emit connected event when actually connected
-            if (conn.state === 'connected') {
-                this.events.emit('connected', conn);
-            }
-            return conn;
+            return connection;
         }
-        catch (error) {
+        catch (err) {
             this.isConnecting = false;
+            const error = err instanceof Error ? err : new Error(String(err));
             this.events.emit('error', error);
             throw error;
         }
@@ -118,69 +98,61 @@ export class ServiceClient {
     /**
      * Disconnect from the service
      */
-    disconnect() {
-        if (this.reconnectTimeout) {
-            clearTimeout(this.reconnectTimeout);
-            this.reconnectTimeout = null;
+    dispose() {
+        if (this.signaler) {
+            this.signaler.dispose();
+            this.signaler = null;
         }
         if (this.connection) {
             this.connection.disconnect();
             this.connection = null;
         }
-        this.bin.clean();
+        this.isConnecting = false;
         this.reconnectAttempts = 0;
     }
     /**
-     * Get the current connection
+     * @deprecated Use dispose() instead
      */
-    getConnection() {
-        return this.connection;
-    }
-    /**
-     * Check if currently connected
-     */
-    isConnected() {
-        return this.connection?.state === 'connected';
+    disconnect() {
+        this.dispose();
     }
     /**
-     * Handle connection state changes
+     * Attempt to reconnect
      */
-    handleConnectionStateChange(state) {
-        if (state === 'connected') {
-            this.events.emit('connected', this.connection);
-            this.reconnectAttempts = 0;
+    async attemptReconnect() {
+        this.reconnectAttempts++;
+        this.events.emit('reconnecting', {
+            attempt: this.reconnectAttempts,
+            maxAttempts: this.maxReconnectAttempts
+        });
+        // Cleanup old connection
+        if (this.signaler) {
+            this.signaler.dispose();
+            this.signaler = null;
+        }
+        if (this.connection) {
+            this.connection = null;
         }
-        else if (state === 'disconnected') {
-            this.events.emit('disconnected', { reason: 'Connection closed' });
-            // Attempt reconnection if enabled
-            if (this.autoReconnect && this.reconnectAttempts < this.maxReconnectAttempts) {
-                this.scheduleReconnect();
+        // Wait a bit before reconnecting
+        await new Promise(resolve => setTimeout(resolve, 1000 * this.reconnectAttempts));
+        try {
+            await this.connect();
+        }
+        catch (err) {
+            console.error('Reconnection attempt failed:', err);
+            if (this.reconnectAttempts < this.maxReconnectAttempts) {
+                this.attemptReconnect();
+            }
+            else {
+                const error = new Error('Max reconnection attempts reached');
+                this.events.emit('error', error);
             }
         }
     }
     /**
-     * Schedule a reconnection attempt
+     * Get the current connection
      */
-    scheduleReconnect() {
-        if (this.reconnectTimeout) {
-            return;
-        }
-        this.reconnectAttempts++;
-        this.events.emit('reconnecting', {
-            attempt: this.reconnectAttempts,
-            maxAttempts: this.maxReconnectAttempts,
-        });
-        // Exponential backoff
-        const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
-        this.reconnectTimeout = setTimeout(() => {
-            this.reconnectTimeout = null;
-            this.connect().catch(error => {
-                this.events.emit('error', error);
-                // Schedule next attempt if we haven't exceeded max attempts
-                if (this.reconnectAttempts < this.maxReconnectAttempts) {
-                    this.scheduleReconnect();
-                }
-            });
-        }, delay);
+    getConnection() {
+        return this.connection;
     }
 }

package/dist/service-host.d.ts

@@ -1,103 +1,67 @@
-import { WebRTCRondevuConnection } from './connection.js';
 import { RondevuService } from './rondevu-service.js';
+import { RTCDurableConnection } from './durable-connection.js';
 import { EventBus } from './event-bus.js';
-import { ConnectionInterface } from './types.js';
 export interface ServiceHostOptions {
     service: string;
     rondevuService: RondevuService;
     maxPeers?: number;
     ttl?: number;
     isPublic?: boolean;
-    metadata?: Record<string, any>;
     rtcConfiguration?: RTCConfiguration;
+    metadata?: Record<string, any>;
 }
 export interface ServiceHostEvents {
-    connection: ConnectionInterface;
-    'connection-closed': {
-        connectionId: string;
-        reason: string;
-    };
+    connection: RTCDurableConnection;
     error: Error;
 }
 /**
- * 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 declare class ServiceHost {
+    private options;
+    events: EventBus<ServiceHostEvents>;
+    private signaler;
+    private webrtcContext;
     private connections;
-    private readonly service;
-    private readonly rondevuService;
-    private readonly maxPeers;
-    private readonly ttl;
-    private readonly isPublic;
-    private readonly metadata?;
-    private readonly rtcConfiguration?;
-    private readonly bin;
-    private isStarted;
-    readonly events: EventBus<ServiceHostEvents>;
+    private maxPeers;
+    private running;
     constructor(options: ServiceHostOptions);
     /**
-     * Start hosting the service - creates initial pool of offers
+     * Start hosting the service
      */
     start(): Promise<void>;
     /**
-     * Stop hosting - closes all connections and cleans up
-     */
-    stop(): void;
-    /**
-     * Get current number of active connections
+     * Create the next connection for incoming peers
      */
-    getConnectionCount(): number;
+    private createNextConnection;
     /**
-     * Get current number of pending offers
+     * Stop hosting the service
      */
-    getPendingOfferCount(): number;
-    /**
-     * Fill the offer pool up to maxPeers
-     */
-    private fillOfferPool;
-    /**
-     * Create a single offer and publish it
-     */
-    private createOffer;
-    /**
-     * Handle connection state changes
-     */
-    private handleConnectionStateChange;
+    dispose(): void;
     /**
      * Get all active connections
      */
-    getConnections(): WebRTCRondevuConnection[];
-    /**
-     * Get a specific connection by ID
-     */
-    getConnection(connectionId: string): WebRTCRondevuConnection | undefined;
+    getConnections(): RTCDurableConnection[];
 }