@xtr-dev/rondevu-client 0.8.3 → 0.9.2

package/dist/peer/index.js

@@ -31,7 +31,7 @@ export default class RondevuPeer extends EventEmitter {
             { urls: 'stun:stun.l.google.com:19302' },
             { urls: 'stun:stun1.l.google.com:19302' }
         ]
-    }, rtcPeerConnection, rtcSessionDescription, rtcIceCandidate) {
+    }, existingPeerConnection, rtcPeerConnection, rtcSessionDescription, rtcIceCandidate) {
         super();
         this.offersApi = offersApi;
         // Use provided polyfills or fall back to globals
@@ -50,7 +50,8 @@ export default class RondevuPeer extends EventEmitter {
             : (() => {
                 throw new Error('RTCIceCandidate is not available. Please provide it in the Rondevu constructor options for Node.js environments.');
             }));
-        this.pc = new this.RTCPeerConnection(rtcConfig);
+        // Use existing peer connection if provided, otherwise create new one
+        this.pc = existingPeerConnection || new this.RTCPeerConnection(rtcConfig);
         this._state = new IdleState(this);
         this.setupPeerConnection();
     }
@@ -59,24 +60,39 @@ export default class RondevuPeer extends EventEmitter {
      */
     setupPeerConnection() {
         this.connectionStateChangeHandler = () => {
+            console.log(`🔌 Connection state changed: ${this.pc.connectionState}`);
             switch (this.pc.connectionState) {
                 case 'connected':
+                    console.log('✅ WebRTC connection established');
                     this.setState(new ConnectedState(this));
                     this.emitEvent('connected');
                     break;
                 case 'disconnected':
+                    console.log('⚠️ WebRTC connection disconnected');
                     this.emitEvent('disconnected');
                     break;
                 case 'failed':
+                    console.log('❌ WebRTC connection failed');
                     this.setState(new FailedState(this, new Error('Connection failed')));
                     break;
                 case 'closed':
+                    console.log('🔒 WebRTC connection closed');
                     this.setState(new ClosedState(this));
                     this.emitEvent('disconnected');
                     break;
             }
         };
         this.pc.addEventListener('connectionstatechange', this.connectionStateChangeHandler);
+        // Add ICE connection state logging
+        const iceConnectionStateHandler = () => {
+            console.log(`🧊 ICE connection state: ${this.pc.iceConnectionState}`);
+        };
+        this.pc.addEventListener('iceconnectionstatechange', iceConnectionStateHandler);
+        // Add ICE gathering state logging
+        const iceGatheringStateHandler = () => {
+            console.log(`🔍 ICE gathering state: ${this.pc.iceGatheringState}`);
+        };
+        this.pc.addEventListener('icegatheringstatechange', iceGatheringStateHandler);
         this.dataChannelHandler = (event) => {
             this.emitEvent('datachannel', event.channel);
         };
@@ -86,7 +102,13 @@ export default class RondevuPeer extends EventEmitter {
         };
         this.pc.addEventListener('track', this.trackHandler);
         this.iceCandidateErrorHandler = (event) => {
-            console.error('ICE candidate error:', event);
+            const iceError = event;
+            console.error(`❌ ICE candidate error: ${iceError.errorText || 'Unknown error'}`, {
+                errorCode: iceError.errorCode,
+                url: iceError.url,
+                address: iceError.address,
+                port: iceError.port
+            });
         };
         this.pc.addEventListener('icecandidateerror', this.iceCandidateErrorHandler);
     }

package/dist/peer/state.js

@@ -30,14 +30,22 @@ export class PeerState {
             if (event.candidate && this.peer.offerId) {
                 const candidateData = event.candidate.toJSON();
                 if (candidateData.candidate && candidateData.candidate !== '') {
+                    const type = candidateData.candidate.includes('typ host') ? 'host' :
+                        candidateData.candidate.includes('typ srflx') ? 'srflx' :
+                            candidateData.candidate.includes('typ relay') ? 'relay' : 'unknown';
+                    console.log(`🧊 Generated ${type} ICE candidate:`, candidateData.candidate);
                     try {
                         await this.peer.offersApi.addIceCandidates(this.peer.offerId, [candidateData]);
+                        console.log(`✅ Sent ${type} ICE candidate to server`);
                     }
                     catch (err) {
-                        console.error('Error sending ICE candidate:', err);
+                        console.error(`❌ Error sending ${type} ICE candidate:`, err);
                     }
                 }
             }
+            else if (!event.candidate) {
+                console.log('🧊 ICE gathering complete (null candidate)');
+            }
         };
         this.peer.pc.addEventListener('icecandidate', this.iceCandidateHandler);
     }

package/dist/rondevu.d.ts

@@ -1,9 +1,11 @@
 import { RondevuAuth, Credentials, FetchFunction } from './auth.js';
 import { RondevuOffers } from './offers.js';
 import { RondevuUsername } from './usernames.js';
-import { RondevuServices } from './services.js';
-import { RondevuDiscovery } from './discovery.js';
 import RondevuPeer from './peer/index.js';
+import { DurableService } from './durable/service.js';
+import { DurableConnection } from './durable/connection.js';
+import { DurableChannel } from './durable/channel.js';
+import type { DurableServiceConfig, DurableConnectionConfig } from './durable/types.js';
 export interface RondevuOptions {
     /**
      * Base URL of the Rondevu server
@@ -63,8 +65,6 @@ export declare class Rondevu {
     readonly auth: RondevuAuth;
     readonly usernames: RondevuUsername;
     private _offers?;
-    private _services?;
-    private _discovery?;
     private credentials?;
     private baseUrl;
     private fetchFn?;
@@ -74,17 +74,9 @@ export declare class Rondevu {
     constructor(options?: RondevuOptions);
     /**
      * Get offers API (low-level access, requires authentication)
-     * For most use cases, use services and discovery APIs instead
+     * For most use cases, use the durable connection APIs instead
      */
     get offers(): RondevuOffers;
-    /**
-     * Get services API (requires authentication)
-     */
-    get services(): RondevuServices;
-    /**
-     * Get discovery API (requires authentication)
-     */
-    get discovery(): RondevuDiscovery;
     /**
      * Register and initialize authenticated client
      * Generates a cryptographically random peer ID (128-bit)
@@ -106,4 +98,87 @@ export declare class Rondevu {
      * @returns RondevuPeer instance
      */
     createPeer(rtcConfig?: RTCConfiguration): RondevuPeer;
+    /**
+     * Expose a durable service with automatic reconnection and TTL refresh
+     *
+     * Creates a service that handles incoming connections with automatic
+     * reconnection and message queuing during network interruptions.
+     *
+     * @param config Service configuration
+     * @returns DurableService instance
+     *
+     * @example
+     * ```typescript
+     * const service = await client.exposeService({
+     *   username: 'alice',
+     *   privateKey: keypair.privateKey,
+     *   serviceFqn: 'chat@1.0.0',
+     *   poolSize: 10,
+     *   handler: (channel, connectionId) => {
+     *     channel.on('message', (data) => {
+     *       console.log('Received:', data);
+     *       channel.send(`Echo: ${data}`);
+     *     });
+     *   }
+     * });
+     *
+     * await service.start();
+     * ```
+     */
+    exposeService(config: DurableServiceConfig & {
+        handler: (channel: DurableChannel, connectionId: string) => void | Promise<void>;
+    }): Promise<DurableService>;
+    /**
+     * Create a durable connection to a service by username and service FQN
+     *
+     * Establishes a WebRTC connection with automatic reconnection and
+     * message queuing during network interruptions.
+     *
+     * @param username Username of the service provider
+     * @param serviceFqn Fully qualified service name
+     * @param config Optional connection configuration
+     * @returns DurableConnection instance
+     *
+     * @example
+     * ```typescript
+     * const connection = await client.connect('alice', 'chat@1.0.0', {
+     *   maxReconnectAttempts: 5
+     * });
+     *
+     * const channel = connection.createChannel('main');
+     * channel.on('message', (data) => {
+     *   console.log('Received:', data);
+     * });
+     *
+     * await connection.connect();
+     * channel.send('Hello!');
+     * ```
+     */
+    connect(username: string, serviceFqn: string, config?: DurableConnectionConfig): Promise<DurableConnection>;
+    /**
+     * Create a durable connection to a service by UUID
+     *
+     * Establishes a WebRTC connection with automatic reconnection and
+     * message queuing during network interruptions.
+     *
+     * @param uuid Service UUID
+     * @param config Optional connection configuration
+     * @returns DurableConnection instance
+     *
+     * @example
+     * ```typescript
+     * const connection = await client.connectByUuid('service-uuid-here', {
+     *   maxReconnectAttempts: 5
+     * });
+     *
+     * const channel = connection.createChannel('main');
+     * channel.on('message', (data) => {
+     *   console.log('Received:', data);
+     * });
+     *
+     * await connection.connect();
+     * channel.send('Hello!');
+     * ```
+     */
+    connectByUuid(uuid: string, config?: DurableConnectionConfig): Promise<DurableConnection>;
 }

package/dist/rondevu.js

@@ -1,9 +1,9 @@
 import { RondevuAuth } from './auth.js';
 import { RondevuOffers } from './offers.js';
 import { RondevuUsername } from './usernames.js';
-import { RondevuServices } from './services.js';
-import { RondevuDiscovery } from './discovery.js';
 import RondevuPeer from './peer/index.js';
+import { DurableService } from './durable/service.js';
+import { DurableConnection } from './durable/connection.js';
 export class Rondevu {
     constructor(options = {}) {
         this.baseUrl = options.baseUrl || 'https://api.ronde.vu';
@@ -16,13 +16,11 @@ export class Rondevu {
         if (options.credentials) {
             this.credentials = options.credentials;
             this._offers = new RondevuOffers(this.baseUrl, this.credentials, this.fetchFn);
-            this._services = new RondevuServices(this.baseUrl, this.credentials);
-            this._discovery = new RondevuDiscovery(this.baseUrl, this.credentials);
         }
     }
     /**
      * Get offers API (low-level access, requires authentication)
-     * For most use cases, use services and discovery APIs instead
+     * For most use cases, use the durable connection APIs instead
      */
     get offers() {
         if (!this._offers) {
@@ -30,34 +28,14 @@ export class Rondevu {
         }
         return this._offers;
     }
-    /**
-     * Get services API (requires authentication)
-     */
-    get services() {
-        if (!this._services) {
-            throw new Error('Not authenticated. Call register() first or provide credentials.');
-        }
-        return this._services;
-    }
-    /**
-     * Get discovery API (requires authentication)
-     */
-    get discovery() {
-        if (!this._discovery) {
-            throw new Error('Not authenticated. Call register() first or provide credentials.');
-        }
-        return this._discovery;
-    }
     /**
      * Register and initialize authenticated client
      * Generates a cryptographically random peer ID (128-bit)
      */
     async register() {
         this.credentials = await this.auth.register();
-        // Create API instances
+        // Create offers API instance
         this._offers = new RondevuOffers(this.baseUrl, this.credentials, this.fetchFn);
-        this._services = new RondevuServices(this.baseUrl, this.credentials);
-        this._discovery = new RondevuDiscovery(this.baseUrl, this.credentials);
         return this.credentials;
     }
     /**
@@ -83,6 +61,111 @@ export class Rondevu {
         if (!this._offers) {
             throw new Error('Not authenticated. Call register() first or provide credentials.');
         }
-        return new RondevuPeer(this._offers, rtcConfig, this.rtcPeerConnection, this.rtcSessionDescription, this.rtcIceCandidate);
+        return new RondevuPeer(this._offers, rtcConfig, undefined, // No existing peer connection
+        this.rtcPeerConnection, this.rtcSessionDescription, this.rtcIceCandidate);
+    }
+    /**
+     * Expose a durable service with automatic reconnection and TTL refresh
+     *
+     * Creates a service that handles incoming connections with automatic
+     * reconnection and message queuing during network interruptions.
+     *
+     * @param config Service configuration
+     * @returns DurableService instance
+     *
+     * @example
+     * ```typescript
+     * const service = await client.exposeService({
+     *   username: 'alice',
+     *   privateKey: keypair.privateKey,
+     *   serviceFqn: 'chat@1.0.0',
+     *   poolSize: 10,
+     *   handler: (channel, connectionId) => {
+     *     channel.on('message', (data) => {
+     *       console.log('Received:', data);
+     *       channel.send(`Echo: ${data}`);
+     *     });
+     *   }
+     * });
+     *
+     * await service.start();
+     * ```
+     */
+    async exposeService(config) {
+        if (!this._offers || !this.credentials) {
+            throw new Error('Not authenticated. Call register() first or provide credentials.');
+        }
+        const service = new DurableService(this._offers, this.baseUrl, this.credentials, config.handler, config);
+        return service;
+    }
+    /**
+     * Create a durable connection to a service by username and service FQN
+     *
+     * Establishes a WebRTC connection with automatic reconnection and
+     * message queuing during network interruptions.
+     *
+     * @param username Username of the service provider
+     * @param serviceFqn Fully qualified service name
+     * @param config Optional connection configuration
+     * @returns DurableConnection instance
+     *
+     * @example
+     * ```typescript
+     * const connection = await client.connect('alice', 'chat@1.0.0', {
+     *   maxReconnectAttempts: 5
+     * });
+     *
+     * const channel = connection.createChannel('main');
+     * channel.on('message', (data) => {
+     *   console.log('Received:', data);
+     * });
+     *
+     * await connection.connect();
+     * channel.send('Hello!');
+     * ```
+     */
+    async connect(username, serviceFqn, config) {
+        if (!this._offers) {
+            throw new Error('Not authenticated. Call register() first or provide credentials.');
+        }
+        const connectionInfo = {
+            username,
+            serviceFqn
+        };
+        return new DurableConnection(this._offers, connectionInfo, config);
+    }
+    /**
+     * Create a durable connection to a service by UUID
+     *
+     * Establishes a WebRTC connection with automatic reconnection and
+     * message queuing during network interruptions.
+     *
+     * @param uuid Service UUID
+     * @param config Optional connection configuration
+     * @returns DurableConnection instance
+     *
+     * @example
+     * ```typescript
+     * const connection = await client.connectByUuid('service-uuid-here', {
+     *   maxReconnectAttempts: 5
+     * });
+     *
+     * const channel = connection.createChannel('main');
+     * channel.on('message', (data) => {
+     *   console.log('Received:', data);
+     * });
+     *
+     * await connection.connect();
+     * channel.send('Hello!');
+     * ```
+     */
+    async connectByUuid(uuid, config) {
+        if (!this._offers) {
+            throw new Error('Not authenticated. Call register() first or provide credentials.');
+        }
+        const connectionInfo = {
+            uuid
+        };
+        return new DurableConnection(this._offers, connectionInfo, config);
     }
 }

package/dist/service-pool.d.ts

@@ -1,5 +1,4 @@
 import RondevuPeer from './peer/index.js';
-import { ServiceHandle } from './services.js';
 /**
  * Status information about the pool
  */
@@ -43,9 +42,17 @@ export interface ServicePoolOptions {
     onError?: (error: Error, context: string) => void;
 }
 /**
- * Extended service handle with pool-specific methods
+ * Service handle with pool-specific methods
  */
-export interface PooledServiceHandle extends ServiceHandle {
+export interface PooledServiceHandle {
+    /** Service ID */
+    serviceId: string;
+    /** Service UUID */
+    uuid: string;
+    /** Offer ID */
+    offerId: string;
+    /** Unpublish the service */
+    unpublish: () => Promise<void>;
     /** Get current pool status */
     getStatus: () => PoolStatus;
     /** Manually add offers to the pool */
@@ -63,6 +70,7 @@ export declare class ServicePool {
     private options;
     private offerPool?;
     private connections;
+    private peerConnections;
     private status;
     private serviceId?;
     private uuid?;