@xtr-dev/rondevu-client 0.10.1 → 0.11.0

package/dist/rondevu-service.d.ts

@@ -7,7 +7,9 @@ export interface RondevuServiceOptions {
 }
 export interface PublishServiceOptions {
     serviceFqn: string;
-    sdp: string;
+    offers: Array<{
+        sdp: string;
+    }>;
     ttl?: number;
     isPublic?: boolean;
     metadata?: Record<string, any>;
@@ -36,7 +38,7 @@ export interface PublishServiceOptions {
  * // Publish a service
  * const publishedService = await service.publishService({
  *   serviceFqn: 'chat.app@1.0.0',
- *   sdp: offerSdp,
+ *   offers: [{ sdp: offerSdp }],
  *   ttl: 300000,
  *   isPublic: true,
  * })
@@ -66,6 +68,10 @@ export declare class RondevuService {
      * Get the current keypair (for backup/storage)
      */
     getKeypair(): Keypair | null;
+    /**
+     * Get the username
+     */
+    getUsername(): string;
     /**
      * Get the public key
      */

package/dist/rondevu-service.js

@@ -23,7 +23,7 @@ import { RondevuAPI } from './api.js';
  * // Publish a service
  * const publishedService = await service.publishService({
  *   serviceFqn: 'chat.app@1.0.0',
- *   sdp: offerSdp,
+ *   offers: [{ sdp: offerSdp }],
  *   ttl: 300000,
  *   isPublic: true,
  * })
@@ -48,7 +48,7 @@ export class RondevuService {
         // Register with API if no credentials provided
         if (!this.api['credentials']) {
             const credentials = await this.api.register();
-            this.api.credentials = credentials;
+            this.api.setCredentials(credentials);
         }
     }
     /**
@@ -70,7 +70,7 @@ export class RondevuService {
             throw new Error(`Username "${this.username}" is already claimed by another user`);
         }
         // Generate signature for username claim
-        const message = `claim-username-${this.username}-${Date.now()}`;
+        const message = `claim:${this.username}:${Date.now()}`;
         const signature = await RondevuAPI.signMessage(message, this.keypair.privateKey);
         // Claim the username
         await this.api.claimUsername(this.username, this.keypair.publicKey, signature, message);
@@ -86,15 +86,15 @@ export class RondevuService {
         if (!this.usernameClaimed) {
             throw new Error('Username not claimed. Call claimUsername() first or the server will reject the service.');
         }
-        const { serviceFqn, sdp, ttl, isPublic, metadata } = options;
+        const { serviceFqn, offers, ttl, isPublic, metadata } = options;
         // Generate signature for service publication
-        const message = `publish-${this.username}-${serviceFqn}-${Date.now()}`;
+        const message = `publish:${this.username}:${serviceFqn}:${Date.now()}`;
         const signature = await RondevuAPI.signMessage(message, this.keypair.privateKey);
         // Create service request
         const serviceRequest = {
             username: this.username,
             serviceFqn,
-            sdp,
+            offers,
             signature,
             message,
             ttl,
@@ -110,6 +110,12 @@ export class RondevuService {
     getKeypair() {
         return this.keypair;
     }
+    /**
+     * Get the username
+     */
+    getUsername() {
+        return this.username;
+    }
     /**
      * Get the public key
      */

package/dist/rondevu-signaler.d.ts

@@ -0,0 +1,110 @@
+import { Signaler } from './types.js';
+import { RondevuService } from './rondevu-service.js';
+import { Binnable } from './bin.js';
+export interface PollingConfig {
+    initialInterval?: number;
+    maxInterval?: number;
+    backoffMultiplier?: number;
+    maxRetries?: number;
+    jitter?: boolean;
+}
+/**
+ * RondevuSignaler - Handles WebRTC signaling via Rondevu service
+ *
+ * Manages offer/answer exchange and ICE candidate polling for establishing
+ * WebRTC connections through the Rondevu signaling server.
+ *
+ * Supports configurable polling with exponential backoff and jitter to reduce
+ * server load and prevent thundering herd issues.
+ *
+ * @example
+ * ```typescript
+ * const signaler = new RondevuSignaler(
+ *   rondevuService,
+ *   'chat.app@1.0.0',
+ *   'peer-username',
+ *   { initialInterval: 500, maxInterval: 5000, jitter: true }
+ * )
+ *
+ * // For offerer:
+ * await signaler.setOffer(offer)
+ * signaler.addAnswerListener(answer => {
+ *   // Handle remote answer
+ * })
+ *
+ * // For answerer:
+ * signaler.addOfferListener(offer => {
+ *   // Handle remote offer
+ * })
+ * await signaler.setAnswer(answer)
+ * ```
+ */
+export declare class RondevuSignaler implements Signaler {
+    private readonly rondevu;
+    private readonly service;
+    private readonly host?;
+    private offerId;
+    private serviceUuid;
+    private offerListeners;
+    private answerListeners;
+    private iceListeners;
+    private answerPollingTimeout;
+    private icePollingTimeout;
+    private lastIceTimestamp;
+    private isPolling;
+    private pollingConfig;
+    constructor(rondevu: RondevuService, service: string, host?: string | undefined, pollingConfig?: PollingConfig);
+    /**
+     * Publish an offer as a service
+     * Used by the offerer to make their offer available
+     */
+    setOffer(offer: RTCSessionDescriptionInit): Promise<void>;
+    /**
+     * Send an answer to the offerer
+     * Used by the answerer to respond to an offer
+     */
+    setAnswer(answer: RTCSessionDescriptionInit): Promise<void>;
+    /**
+     * Listen for incoming offers
+     * Used by the answerer to receive offers from the offerer
+     */
+    addOfferListener(callback: (offer: RTCSessionDescriptionInit) => void): Binnable;
+    /**
+     * Listen for incoming answers
+     * Used by the offerer to receive the answer from the answerer
+     */
+    addAnswerListener(callback: (answer: RTCSessionDescriptionInit) => void): Binnable;
+    /**
+     * Send an ICE candidate to the remote peer
+     */
+    addIceCandidate(candidate: RTCIceCandidate): Promise<void>;
+    /**
+     * Listen for ICE candidates from the remote peer
+     */
+    addListener(callback: (candidate: RTCIceCandidate) => void): Binnable;
+    /**
+     * Search for an offer from the host
+     * Used by the answerer to find the offerer's service
+     */
+    private searchForOffer;
+    /**
+     * Start polling for answer (offerer side) with exponential backoff
+     */
+    private startAnswerPolling;
+    /**
+     * Stop polling for answer
+     */
+    private stopAnswerPolling;
+    /**
+     * Start polling for ICE candidates with adaptive backoff
+     */
+    private startIcePolling;
+    /**
+     * Stop polling for ICE candidates
+     */
+    private stopIcePolling;
+    /**
+     * Stop all polling and cleanup
+     */
+    dispose(): void;
+}

package/dist/rondevu-signaler.js

@@ -0,0 +1,372 @@
+/**
+ * RondevuSignaler - Handles WebRTC signaling via Rondevu service
+ *
+ * Manages offer/answer exchange and ICE candidate polling for establishing
+ * WebRTC connections through the Rondevu signaling server.
+ *
+ * Supports configurable polling with exponential backoff and jitter to reduce
+ * server load and prevent thundering herd issues.
+ *
+ * @example
+ * ```typescript
+ * const signaler = new RondevuSignaler(
+ *   rondevuService,
+ *   'chat.app@1.0.0',
+ *   'peer-username',
+ *   { initialInterval: 500, maxInterval: 5000, jitter: true }
+ * )
+ *
+ * // For offerer:
+ * await signaler.setOffer(offer)
+ * signaler.addAnswerListener(answer => {
+ *   // Handle remote answer
+ * })
+ *
+ * // For answerer:
+ * signaler.addOfferListener(offer => {
+ *   // Handle remote offer
+ * })
+ * await signaler.setAnswer(answer)
+ * ```
+ */
+export class RondevuSignaler {
+    constructor(rondevu, service, host, pollingConfig) {
+        this.rondevu = rondevu;
+        this.service = service;
+        this.host = host;
+        this.offerId = null;
+        this.serviceUuid = null;
+        this.offerListeners = [];
+        this.answerListeners = [];
+        this.iceListeners = [];
+        this.answerPollingTimeout = null;
+        this.icePollingTimeout = null;
+        this.lastIceTimestamp = 0;
+        this.isPolling = false;
+        this.pollingConfig = {
+            initialInterval: pollingConfig?.initialInterval ?? 500,
+            maxInterval: pollingConfig?.maxInterval ?? 5000,
+            backoffMultiplier: pollingConfig?.backoffMultiplier ?? 1.5,
+            maxRetries: pollingConfig?.maxRetries ?? 50,
+            jitter: pollingConfig?.jitter ?? true
+        };
+    }
+    /**
+     * Publish an offer as a service
+     * Used by the offerer to make their offer available
+     */
+    async setOffer(offer) {
+        if (!offer.sdp) {
+            throw new Error('Offer SDP is required');
+        }
+        // Publish service with the offer SDP
+        const publishedService = await this.rondevu.publishService({
+            serviceFqn: this.service,
+            offers: [{ sdp: offer.sdp }],
+            ttl: 300000, // 5 minutes
+            isPublic: true,
+        });
+        // Get the first offer from the published service
+        if (!publishedService.offers || publishedService.offers.length === 0) {
+            throw new Error('No offers returned from service publication');
+        }
+        this.offerId = publishedService.offers[0].offerId;
+        this.serviceUuid = publishedService.uuid;
+        // Start polling for answer
+        this.startAnswerPolling();
+        // Start polling for ICE candidates
+        this.startIcePolling();
+    }
+    /**
+     * Send an answer to the offerer
+     * Used by the answerer to respond to an offer
+     */
+    async setAnswer(answer) {
+        if (!answer.sdp) {
+            throw new Error('Answer SDP is required');
+        }
+        if (!this.offerId) {
+            throw new Error('No offer ID available. Must receive offer first.');
+        }
+        // Send answer to the offer
+        await this.rondevu.getAPI().answerOffer(this.offerId, answer.sdp);
+        // Start polling for ICE candidates
+        this.startIcePolling();
+    }
+    /**
+     * Listen for incoming offers
+     * Used by the answerer to receive offers from the offerer
+     */
+    addOfferListener(callback) {
+        this.offerListeners.push(callback);
+        // If we have a host, start searching for their service
+        if (this.host && !this.isPolling) {
+            this.searchForOffer();
+        }
+        // Return cleanup function
+        return () => {
+            const index = this.offerListeners.indexOf(callback);
+            if (index > -1) {
+                this.offerListeners.splice(index, 1);
+            }
+        };
+    }
+    /**
+     * Listen for incoming answers
+     * Used by the offerer to receive the answer from the answerer
+     */
+    addAnswerListener(callback) {
+        this.answerListeners.push(callback);
+        // Return cleanup function
+        return () => {
+            const index = this.answerListeners.indexOf(callback);
+            if (index > -1) {
+                this.answerListeners.splice(index, 1);
+            }
+        };
+    }
+    /**
+     * Send an ICE candidate to the remote peer
+     */
+    async addIceCandidate(candidate) {
+        if (!this.offerId) {
+            console.warn('Cannot send ICE candidate: no offer ID');
+            return;
+        }
+        const candidateData = candidate.toJSON();
+        // Skip empty candidates
+        if (!candidateData.candidate || candidateData.candidate === '') {
+            return;
+        }
+        try {
+            await this.rondevu.getAPI().addIceCandidates(this.offerId, [candidateData]);
+        }
+        catch (err) {
+            console.error('Failed to send ICE candidate:', err);
+        }
+    }
+    /**
+     * Listen for ICE candidates from the remote peer
+     */
+    addListener(callback) {
+        this.iceListeners.push(callback);
+        // Return cleanup function
+        return () => {
+            const index = this.iceListeners.indexOf(callback);
+            if (index > -1) {
+                this.iceListeners.splice(index, 1);
+            }
+        };
+    }
+    /**
+     * Search for an offer from the host
+     * Used by the answerer to find the offerer's service
+     */
+    async searchForOffer() {
+        if (!this.host) {
+            throw new Error('No host specified for offer search');
+        }
+        this.isPolling = true;
+        try {
+            // Search for services by username and service FQN
+            const services = await this.rondevu.getAPI().searchServices(this.host, this.service);
+            if (services.length === 0) {
+                console.warn(`No services found for ${this.host}/${this.service}`);
+                this.isPolling = false;
+                return;
+            }
+            // Get the first available service (already has full details from searchServices)
+            const service = services[0];
+            // Get the first available offer from the service
+            if (!service.offers || service.offers.length === 0) {
+                console.warn(`No offers available for service ${this.host}/${this.service}`);
+                this.isPolling = false;
+                return;
+            }
+            const firstOffer = service.offers[0];
+            this.offerId = firstOffer.offerId;
+            this.serviceUuid = service.uuid;
+            // Notify offer listeners
+            const offer = {
+                type: 'offer',
+                sdp: firstOffer.sdp,
+            };
+            this.offerListeners.forEach(listener => {
+                try {
+                    listener(offer);
+                }
+                catch (err) {
+                    console.error('Offer listener error:', err);
+                }
+            });
+        }
+        catch (err) {
+            console.error('Failed to search for offer:', err);
+            this.isPolling = false;
+        }
+    }
+    /**
+     * Start polling for answer (offerer side) with exponential backoff
+     */
+    startAnswerPolling() {
+        if (this.answerPollingTimeout || !this.offerId) {
+            return;
+        }
+        let interval = this.pollingConfig.initialInterval;
+        let retries = 0;
+        const poll = async () => {
+            if (!this.offerId) {
+                this.stopAnswerPolling();
+                return;
+            }
+            try {
+                const answer = await this.rondevu.getAPI().getAnswer(this.offerId);
+                if (answer && answer.sdp) {
+                    // Got answer - notify listeners and stop polling
+                    const answerDesc = {
+                        type: 'answer',
+                        sdp: answer.sdp,
+                    };
+                    this.answerListeners.forEach(listener => {
+                        try {
+                            listener(answerDesc);
+                        }
+                        catch (err) {
+                            console.error('Answer listener error:', err);
+                        }
+                    });
+                    // Stop polling once we get the answer
+                    this.stopAnswerPolling();
+                    return;
+                }
+                // No answer yet - exponential backoff
+                retries++;
+                if (retries > this.pollingConfig.maxRetries) {
+                    console.warn('Max retries reached for answer polling');
+                    this.stopAnswerPolling();
+                    return;
+                }
+                interval = Math.min(interval * this.pollingConfig.backoffMultiplier, this.pollingConfig.maxInterval);
+                // Add jitter to prevent thundering herd
+                const finalInterval = this.pollingConfig.jitter
+                    ? interval + Math.random() * 100
+                    : interval;
+                this.answerPollingTimeout = setTimeout(poll, finalInterval);
+            }
+            catch (err) {
+                // 404 is expected when answer isn't available yet
+                if (err instanceof Error && !err.message?.includes('404')) {
+                    console.error('Error polling for answer:', err);
+                }
+                // Retry with backoff
+                const finalInterval = this.pollingConfig.jitter
+                    ? interval + Math.random() * 100
+                    : interval;
+                this.answerPollingTimeout = setTimeout(poll, finalInterval);
+            }
+        };
+        poll(); // Start immediately
+    }
+    /**
+     * Stop polling for answer
+     */
+    stopAnswerPolling() {
+        if (this.answerPollingTimeout) {
+            clearTimeout(this.answerPollingTimeout);
+            this.answerPollingTimeout = null;
+        }
+    }
+    /**
+     * Start polling for ICE candidates with adaptive backoff
+     */
+    startIcePolling() {
+        if (this.icePollingTimeout || !this.offerId) {
+            return;
+        }
+        let interval = this.pollingConfig.initialInterval;
+        const poll = async () => {
+            if (!this.offerId) {
+                this.stopIcePolling();
+                return;
+            }
+            try {
+                const candidates = await this.rondevu
+                    .getAPI()
+                    .getIceCandidates(this.offerId, this.lastIceTimestamp);
+                let foundCandidates = false;
+                for (const item of candidates) {
+                    if (item.candidate && item.candidate.candidate && item.candidate.candidate !== '') {
+                        foundCandidates = true;
+                        try {
+                            const rtcCandidate = new RTCIceCandidate(item.candidate);
+                            this.iceListeners.forEach(listener => {
+                                try {
+                                    listener(rtcCandidate);
+                                }
+                                catch (err) {
+                                    console.error('ICE listener error:', err);
+                                }
+                            });
+                            this.lastIceTimestamp = item.createdAt;
+                        }
+                        catch (err) {
+                            console.warn('Failed to process ICE candidate:', err);
+                            this.lastIceTimestamp = item.createdAt;
+                        }
+                    }
+                    else {
+                        this.lastIceTimestamp = item.createdAt;
+                    }
+                }
+                // If candidates found, reset interval to initial value
+                // Otherwise, increase interval with backoff
+                if (foundCandidates) {
+                    interval = this.pollingConfig.initialInterval;
+                }
+                else {
+                    interval = Math.min(interval * this.pollingConfig.backoffMultiplier, this.pollingConfig.maxInterval);
+                }
+                // Add jitter
+                const finalInterval = this.pollingConfig.jitter
+                    ? interval + Math.random() * 100
+                    : interval;
+                this.icePollingTimeout = setTimeout(poll, finalInterval);
+            }
+            catch (err) {
+                // 404/410 means offer expired, stop polling
+                if (err instanceof Error && (err.message?.includes('404') || err.message?.includes('410'))) {
+                    console.warn('Offer not found or expired, stopping ICE polling');
+                    this.stopIcePolling();
+                }
+                else if (err instanceof Error && !err.message?.includes('404')) {
+                    console.error('Error polling for ICE candidates:', err);
+                    // Continue polling despite errors
+                    const finalInterval = this.pollingConfig.jitter
+                        ? interval + Math.random() * 100
+                        : interval;
+                    this.icePollingTimeout = setTimeout(poll, finalInterval);
+                }
+            }
+        };
+        poll(); // Start immediately
+    }
+    /**
+     * Stop polling for ICE candidates
+     */
+    stopIcePolling() {
+        if (this.icePollingTimeout) {
+            clearTimeout(this.icePollingTimeout);
+            this.icePollingTimeout = null;
+        }
+    }
+    /**
+     * Stop all polling and cleanup
+     */
+    dispose() {
+        this.stopAnswerPolling();
+        this.stopIcePolling();
+        this.offerListeners = [];
+        this.answerListeners = [];
+        this.iceListeners = [];
+    }
+}

package/dist/service-client.d.ts

@@ -1,21 +1,17 @@
-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 ServiceClientOptions {
     username: string;
     serviceFqn: string;
     rondevuService: RondevuService;
     autoReconnect?: boolean;
-    reconnectDelay?: number;
     maxReconnectAttempts?: number;
     rtcConfiguration?: RTCConfiguration;
 }
 export interface ServiceClientEvents {
-    connected: ConnectionInterface;
-    disconnected: {
-        reason: string;
-    };
+    connected: RTCDurableConnection;
+    disconnected: void;
     reconnecting: {
         attempt: number;
         maxAttempts: number;
@@ -23,72 +19,59 @@ export interface ServiceClientEvents {
     error: Error;
 }
 /**
- * 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 declare class ServiceClient {
-    private readonly username;
-    private readonly serviceFqn;
-    private readonly rondevuService;
-    private readonly autoReconnect;
-    private readonly reconnectDelay;
-    private readonly maxReconnectAttempts;
-    private readonly rtcConfiguration?;
+    private options;
+    events: EventBus<ServiceClientEvents>;
+    private signaler;
+    private webrtcContext;
     private connection;
+    private autoReconnect;
+    private maxReconnectAttempts;
     private reconnectAttempts;
-    private reconnectTimeout;
-    private readonly bin;
     private isConnecting;
-    readonly events: EventBus<ServiceClientEvents>;
     constructor(options: ServiceClientOptions);
     /**
      * Connect to the service
      */
-    connect(): Promise<WebRTCRondevuConnection>;
+    connect(): Promise<RTCDurableConnection>;
     /**
      * Disconnect from the service
      */
-    disconnect(): void;
-    /**
-     * Get the current connection
-     */
-    getConnection(): WebRTCRondevuConnection | null;
+    dispose(): void;
     /**
-     * Check if currently connected
+     * @deprecated Use dispose() instead
      */
-    isConnected(): boolean;
+    disconnect(): void;
     /**
-     * Handle connection state changes
+     * Attempt to reconnect
      */
-    private handleConnectionStateChange;
+    private attemptReconnect;
     /**
-     * Schedule a reconnection attempt
+     * Get the current connection
      */
-    private scheduleReconnect;
+    getConnection(): RTCDurableConnection | null;
 }