@xtr-dev/rondevu-client 0.8.3 → 0.9.2

package/dist/service-pool.js

@@ -14,6 +14,7 @@ export class ServicePool {
         this.credentials = credentials;
         this.options = options;
         this.connections = new Map();
+        this.peerConnections = new Map();
         this.status = {
             activeOffers: 0,
             activeConnections: 0,
@@ -34,10 +35,14 @@ export class ServicePool {
         this.uuid = service.uuid;
         // 2. Create additional offers for pool (poolSize - 1)
         const additionalOffers = [];
+        const additionalPeerConnections = [];
+        const additionalDataChannels = [];
         if (poolSize > 1) {
             try {
-                const offers = await this.createOffers(poolSize - 1);
-                additionalOffers.push(...offers);
+                const result = await this.createOffers(poolSize - 1);
+                additionalOffers.push(...result.offers);
+                additionalPeerConnections.push(...result.peerConnections);
+                additionalDataChannels.push(...result.dataChannels);
             }
             catch (error) {
                 this.handleError(error, 'initial-offer-creation');
@@ -51,12 +56,20 @@ export class ServicePool {
             onRefill: (count) => this.createOffers(count),
             onError: (err, ctx) => this.handleError(err, ctx)
         });
-        // Add all offers to pool
+        // Add all offers to pool with their peer connections and data channels
         const allOffers = [
-            { id: service.offerId, peerId: this.credentials.peerId, sdp: '', topics: [], expiresAt: service.expiresAt, lastSeen: Date.now() },
+            { id: service.offerId, peerId: this.credentials.peerId, sdp: service.offerSdp, topics: [], expiresAt: service.expiresAt, lastSeen: Date.now() },
             ...additionalOffers
         ];
-        await this.offerPool.addOffers(allOffers);
+        const allPeerConnections = [
+            service.peerConnection,
+            ...additionalPeerConnections
+        ];
+        const allDataChannels = [
+            service.dataChannel,
+            ...additionalDataChannels
+        ];
+        await this.offerPool.addOffers(allOffers, allPeerConnections, allDataChannels);
         // 4. Start polling
         await this.offerPool.start();
         // Update status
@@ -79,12 +92,24 @@ export class ServicePool {
         if (this.offerPool) {
             await this.offerPool.stop();
         }
-        // 2. Delete remaining offers
+        // 2. Close peer connections from the pool
+        if (this.offerPool) {
+            const poolPeerConnections = this.offerPool.getActivePeerConnections();
+            poolPeerConnections.forEach(pc => {
+                try {
+                    pc.close();
+                }
+                catch {
+                    // Ignore errors during cleanup
+                }
+            });
+        }
+        // 3. Delete remaining offers
         if (this.offerPool) {
             const offerIds = this.offerPool.getActiveOfferIds();
             await Promise.allSettled(offerIds.map(id => this.offersApi.delete(id).catch(() => { })));
         }
-        // 3. Close active connections
+        // 4. Close active connections
         const closePromises = Array.from(this.connections.values()).map(async (conn) => {
             try {
                 // Give a brief moment for graceful closure
@@ -96,7 +121,7 @@ export class ServicePool {
             }
         });
         await Promise.allSettled(closePromises);
-        // 4. Delete service if we have a serviceId
+        // 5. Delete service if we have a serviceId
         if (this.serviceId) {
             try {
                 const response = await fetch(`${this.baseUrl}/services/${this.serviceId}`, {
@@ -125,41 +150,52 @@ export class ServicePool {
     async handleConnection(answer) {
         const connectionId = this.generateConnectionId();
         try {
-            // Create peer connection
+            // Use the existing peer connection from the pool
             const peer = new RondevuPeer(this.offersApi, this.options.rtcConfig || {
                 iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
-            });
+            }, answer.peerConnection // Use the existing peer connection
+            );
             peer.role = 'offerer';
             peer.offerId = answer.offerId;
+            // Verify peer connection is in correct state
+            if (peer.pc.signalingState !== 'have-local-offer') {
+                console.error('Peer connection state info:', {
+                    signalingState: peer.pc.signalingState,
+                    connectionState: peer.pc.connectionState,
+                    iceConnectionState: peer.pc.iceConnectionState,
+                    iceGatheringState: peer.pc.iceGatheringState,
+                    hasLocalDescription: !!peer.pc.localDescription,
+                    hasRemoteDescription: !!peer.pc.remoteDescription,
+                    localDescriptionType: peer.pc.localDescription?.type,
+                    remoteDescriptionType: peer.pc.remoteDescription?.type,
+                    offerId: answer.offerId
+                });
+                throw new Error(`Invalid signaling state: ${peer.pc.signalingState}. Expected 'have-local-offer' to set remote answer.`);
+            }
             // Set remote description (the answer)
             await peer.pc.setRemoteDescription({
                 type: 'answer',
                 sdp: answer.sdp
             });
-            // Wait for data channel (answerer creates it, we receive it)
-            const channel = await new Promise((resolve, reject) => {
-                const timeout = setTimeout(() => reject(new Error('Timeout waiting for data channel')), 30000);
-                peer.on('datachannel', (ch) => {
-                    clearTimeout(timeout);
-                    resolve(ch);
-                });
-                // Also check if channel already exists
-                if (peer.pc.ondatachannel) {
-                    const existingHandler = peer.pc.ondatachannel;
-                    peer.pc.ondatachannel = (event) => {
+            // Use the data channel we created when making the offer
+            if (!answer.dataChannel) {
+                throw new Error('No data channel found for answered offer');
+            }
+            const channel = answer.dataChannel;
+            // Wait for the channel to open (it was created when we made the offer)
+            if (channel.readyState !== 'open') {
+                await new Promise((resolve, reject) => {
+                    const timeout = setTimeout(() => reject(new Error('Timeout waiting for data channel to open')), 30000);
+                    channel.onopen = () => {
                         clearTimeout(timeout);
-                        resolve(event.channel);
-                        if (existingHandler)
-                            existingHandler.call(peer.pc, event);
+                        resolve();
                     };
-                }
-                else {
-                    peer.pc.ondatachannel = (event) => {
+                    channel.onerror = (error) => {
                         clearTimeout(timeout);
-                        resolve(event.channel);
+                        reject(new Error('Data channel error'));
                     };
-                }
-            });
+                });
+            }
             // Register connection
             this.connections.set(connectionId, {
                 peer,
@@ -199,23 +235,45 @@ export class ServicePool {
      */
     async createOffers(count) {
         if (count <= 0) {
-            return [];
+            return { offers: [], peerConnections: [], dataChannels: [] };
         }
         // Server supports max 10 offers per request
         const batchSize = Math.min(count, 10);
         const offers = [];
+        const peerConnections = [];
+        const dataChannels = [];
         try {
             // Create peer connections and generate offers
             const offerRequests = [];
+            const pendingCandidates = []; // Store candidates before we have offer IDs
             for (let i = 0; i < batchSize; i++) {
                 const pc = new RTCPeerConnection(this.options.rtcConfig || {
                     iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
                 });
-                // Create data channel (required for offers)
-                pc.createDataChannel('rondevu-service');
+                // Create data channel (required for offers) and save reference
+                const channel = pc.createDataChannel('rondevu-service');
+                dataChannels.push(channel);
+                // Set up temporary candidate collector BEFORE setLocalDescription
+                const candidatesForThisOffer = [];
+                pendingCandidates.push(candidatesForThisOffer);
+                pc.onicecandidate = (event) => {
+                    if (event.candidate) {
+                        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(`🧊 Service pool generated ${type} ICE candidate:`, candidateData.candidate);
+                            candidatesForThisOffer.push(candidateData);
+                        }
+                    }
+                    else {
+                        console.log('🧊 Service pool ICE gathering complete');
+                    }
+                };
                 // Create offer
                 const offer = await pc.createOffer();
-                await pc.setLocalDescription(offer);
+                await pc.setLocalDescription(offer); // ICE gathering starts here, candidates go to collector
                 if (!offer.sdp) {
                     pc.close();
                     throw new Error('Failed to generate SDP');
@@ -225,19 +283,57 @@ export class ServicePool {
                     topics: [], // V2 doesn't use topics
                     ttl: this.options.ttl
                 });
-                // Close the PC immediately - we only needed the SDP
-                pc.close();
+                // Keep peer connection alive - DO NOT CLOSE
+                peerConnections.push(pc);
             }
             // Batch create offers
             const createdOffers = await this.offersApi.create(offerRequests);
             offers.push(...createdOffers);
+            // Now send all pending candidates and set up handlers for future ones
+            for (let i = 0; i < peerConnections.length; i++) {
+                const pc = peerConnections[i];
+                const offerId = createdOffers[i].id;
+                const candidates = pendingCandidates[i];
+                // Send any candidates that were collected while waiting for offer ID
+                if (candidates.length > 0) {
+                    console.log(`📤 Sending ${candidates.length} pending ICE candidate(s) for offer ${offerId}`);
+                    try {
+                        await this.offersApi.addIceCandidates(offerId, candidates);
+                        console.log(`✅ Sent ${candidates.length} pending ICE candidate(s)`);
+                    }
+                    catch (err) {
+                        console.error('❌ Error sending pending ICE candidates:', err);
+                    }
+                }
+                // Replace temporary handler with permanent one for any future candidates
+                pc.onicecandidate = async (event) => {
+                    if (event.candidate) {
+                        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(`🧊 Service pool generated late ${type} ICE candidate:`, candidateData.candidate);
+                            try {
+                                await this.offersApi.addIceCandidates(offerId, [candidateData]);
+                                console.log(`✅ Sent late ${type} ICE candidate`);
+                            }
+                            catch (err) {
+                                console.error(`❌ Error sending ${type} ICE candidate:`, err);
+                            }
+                        }
+                    }
+                };
+            }
         }
         catch (error) {
+            // Close any created peer connections on error
+            peerConnections.forEach(pc => pc.close());
             this.status.failedOfferCreations++;
             this.handleError(error, 'offer-creation');
             throw error;
         }
-        return offers;
+        return { offers, peerConnections, dataChannels };
     }
     /**
      * Publish the initial service (creates first offer)
@@ -248,14 +344,34 @@ export class ServicePool {
         const pc = new RTCPeerConnection(rtcConfig || {
             iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
         });
-        pc.createDataChannel('rondevu-service');
+        const dataChannel = pc.createDataChannel('rondevu-service');
+        // Collect candidates before we have offer ID
+        const pendingCandidates = [];
+        // Set up temporary candidate collector BEFORE setLocalDescription
+        pc.onicecandidate = (event) => {
+            if (event.candidate) {
+                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(`🧊 Initial service generated ${type} ICE candidate:`, candidateData.candidate);
+                    pendingCandidates.push(candidateData);
+                }
+            }
+            else {
+                console.log('🧊 Initial service ICE gathering complete');
+            }
+        };
         // Create offer
         const offer = await pc.createOffer();
-        await pc.setLocalDescription(offer);
+        await pc.setLocalDescription(offer); // ICE gathering starts here
         if (!offer.sdp) {
             pc.close();
             throw new Error('Failed to generate SDP');
         }
+        // Store the SDP
+        const offerSdp = offer.sdp;
         // Create signature
         const timestamp = Date.now();
         const message = `publish:${username}:${serviceFqn}:${timestamp}`;
@@ -270,7 +386,7 @@ export class ServicePool {
             body: JSON.stringify({
                 username,
                 serviceFqn,
-                sdp: offer.sdp,
+                sdp: offerSdp,
                 ttl,
                 isPublic,
                 metadata,
@@ -278,17 +394,50 @@ export class ServicePool {
                 message
             })
         });
-        pc.close();
         if (!response.ok) {
+            pc.close();
             const error = await response.json();
             throw new Error(error.error || 'Failed to publish service');
         }
         const data = await response.json();
+        // Send any pending candidates
+        if (pendingCandidates.length > 0) {
+            console.log(`📤 Sending ${pendingCandidates.length} pending ICE candidate(s) for initial service`);
+            try {
+                await this.offersApi.addIceCandidates(data.offerId, pendingCandidates);
+                console.log(`✅ Sent ${pendingCandidates.length} pending ICE candidate(s)`);
+            }
+            catch (err) {
+                console.error('❌ Error sending pending ICE candidates:', err);
+            }
+        }
+        // Set up handler for any future candidates
+        pc.onicecandidate = async (event) => {
+            if (event.candidate) {
+                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(`🧊 Initial service generated late ${type} ICE candidate:`, candidateData.candidate);
+                    try {
+                        await this.offersApi.addIceCandidates(data.offerId, [candidateData]);
+                        console.log(`✅ Sent late ${type} ICE candidate`);
+                    }
+                    catch (err) {
+                        console.error(`❌ Error sending ${type} ICE candidate:`, err);
+                    }
+                }
+            }
+        };
         return {
             serviceId: data.serviceId,
             uuid: data.uuid,
             offerId: data.offerId,
-            expiresAt: data.expiresAt
+            offerSdp,
+            expiresAt: data.expiresAt,
+            peerConnection: pc, // Keep peer connection alive
+            dataChannel // Keep data channel alive
         };
     }
     /**
@@ -298,8 +447,8 @@ export class ServicePool {
         if (!this.offerPool) {
             throw new Error('Pool not started');
         }
-        const offers = await this.createOffers(count);
-        await this.offerPool.addOffers(offers);
+        const result = await this.createOffers(count);
+        await this.offerPool.addOffers(result.offers, result.peerConnections, result.dataChannels);
         this.updateStatus();
     }
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xtr-dev/rondevu-client",
-  "version": "0.8.3",
-  "description": "TypeScript client for Rondevu DNS-like WebRTC with username claiming and service discovery",
+  "version": "0.9.2",
+  "description": "TypeScript client for Rondevu with durable WebRTC connections, automatic reconnection, and message queuing",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/bloom.d.ts

@@ -1,30 +0,0 @@
-/**
- * Simple bloom filter implementation for peer ID exclusion
- * Uses multiple hash functions for better distribution
- */
-export declare class BloomFilter {
-    private bits;
-    private size;
-    private numHashes;
-    constructor(size?: number, numHashes?: number);
-    /**
-     * Add a peer ID to the filter
-     */
-    add(peerId: string): void;
-    /**
-     * Test if peer ID might be in the filter
-     */
-    test(peerId: string): boolean;
-    /**
-     * Get raw bits for transmission
-     */
-    toBytes(): Uint8Array;
-    /**
-     * Convert to base64 for URL parameters
-     */
-    toBase64(): string;
-    /**
-     * Simple hash function (FNV-1a variant)
-     */
-    private hash;
-}

package/dist/bloom.js

@@ -1,73 +0,0 @@
-/**
- * Simple bloom filter implementation for peer ID exclusion
- * Uses multiple hash functions for better distribution
- */
-export class BloomFilter {
-    constructor(size = 1024, numHashes = 3) {
-        this.size = size;
-        this.numHashes = numHashes;
-        this.bits = new Uint8Array(Math.ceil(size / 8));
-    }
-    /**
-     * Add a peer ID to the filter
-     */
-    add(peerId) {
-        for (let i = 0; i < this.numHashes; i++) {
-            const hash = this.hash(peerId, i);
-            const index = hash % this.size;
-            const byteIndex = Math.floor(index / 8);
-            const bitIndex = index % 8;
-            this.bits[byteIndex] |= 1 << bitIndex;
-        }
-    }
-    /**
-     * Test if peer ID might be in the filter
-     */
-    test(peerId) {
-        for (let i = 0; i < this.numHashes; i++) {
-            const hash = this.hash(peerId, i);
-            const index = hash % this.size;
-            const byteIndex = Math.floor(index / 8);
-            const bitIndex = index % 8;
-            if (!(this.bits[byteIndex] & (1 << bitIndex))) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Get raw bits for transmission
-     */
-    toBytes() {
-        return this.bits;
-    }
-    /**
-     * Convert to base64 for URL parameters
-     */
-    toBase64() {
-        // Convert Uint8Array to regular array then to string
-        const binaryString = String.fromCharCode(...Array.from(this.bits));
-        // Use btoa for browser, or Buffer for Node.js
-        if (typeof btoa !== 'undefined') {
-            return btoa(binaryString);
-        }
-        else if (typeof Buffer !== 'undefined') {
-            return Buffer.from(this.bits).toString('base64');
-        }
-        else {
-            // Fallback: manual base64 encoding
-            throw new Error('No base64 encoding available');
-        }
-    }
-    /**
-     * Simple hash function (FNV-1a variant)
-     */
-    hash(str, seed) {
-        let hash = 2166136261 ^ seed;
-        for (let i = 0; i < str.length; i++) {
-            hash ^= str.charCodeAt(i);
-            hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
-        }
-        return hash >>> 0;
-    }
-}

package/dist/client.d.ts

@@ -1,126 +0,0 @@
-import { RondevuClientOptions, CreateOfferRequest, CreateOfferResponse, AnswerRequest, AnswerResponse, PollOffererResponse, PollAnswererResponse, VersionResponse, HealthResponse, Side } from './types.js';
-/**
- * HTTP API client for Rondevu peer signaling server
- */
-export declare class RondevuAPI {
-    private readonly baseUrl;
-    private readonly fetchImpl;
-    /**
-     * Creates a new Rondevu API client instance
-     * @param options - Client configuration options
-     */
-    constructor(options: RondevuClientOptions);
-    /**
-     * Makes an HTTP request to the Rondevu server
-     */
-    private request;
-    /**
-     * Gets server version information
-     *
-     * @returns Server version
-     *
-     * @example
-     * ```typescript
-     * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
-     * const { version } = await api.getVersion();
-     * console.log('Server version:', version);
-     * ```
-     */
-    getVersion(): Promise<VersionResponse>;
-    /**
-     * Creates a new offer
-     *
-     * @param request - Offer details including peer ID, signaling data, and optional custom code
-     * @returns Unique offer code (UUID or custom code)
-     *
-     * @example
-     * ```typescript
-     * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
-     * const { code } = await api.createOffer({
-     *   peerId: 'peer-123',
-     *   offer: signalingData,
-     *   code: 'my-custom-code' // optional
-     * });
-     * console.log('Offer code:', code);
-     * ```
-     */
-    createOffer(request: CreateOfferRequest): Promise<CreateOfferResponse>;
-    /**
-     * Sends an answer or candidate to an existing offer
-     *
-     * @param request - Answer details including offer code and signaling data
-     * @returns Success confirmation
-     *
-     * @example
-     * ```typescript
-     * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
-     *
-     * // Send answer
-     * await api.sendAnswer({
-     *   code: offerCode,
-     *   answer: answerData,
-     *   side: 'answerer'
-     * });
-     *
-     * // Send candidate
-     * await api.sendAnswer({
-     *   code: offerCode,
-     *   candidate: candidateData,
-     *   side: 'offerer'
-     * });
-     * ```
-     */
-    sendAnswer(request: AnswerRequest): Promise<AnswerResponse>;
-    /**
-     * Polls for offer data from the other peer
-     *
-     * @param code - Offer code
-     * @param side - Which side is polling ('offerer' or 'answerer')
-     * @returns Offer data including offers, answers, and candidates
-     *
-     * @example
-     * ```typescript
-     * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
-     *
-     * // Offerer polls for answer
-     * const offererData = await api.poll(offerCode, 'offerer');
-     * if (offererData.answer) {
-     *   console.log('Received answer:', offererData.answer);
-     * }
-     *
-     * // Answerer polls for offer
-     * const answererData = await api.poll(offerCode, 'answerer');
-     * console.log('Received offer:', answererData.offer);
-     * ```
-     */
-    poll(code: string, side: Side): Promise<PollOffererResponse | PollAnswererResponse>;
-    /**
-     * Checks server health and version
-     *
-     * @returns Health status, timestamp, and version
-     *
-     * @example
-     * ```typescript
-     * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
-     * const health = await api.health();
-     * console.log('Server status:', health.status);
-     * console.log('Server version:', health.version);
-     * ```
-     */
-    health(): Promise<HealthResponse>;
-    /**
-     * Ends a session by deleting the offer from the server
-     *
-     * @param code - The offer code
-     * @returns Success confirmation
-     *
-     * @example
-     * ```typescript
-     * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
-     * await api.leave('my-offer-code');
-     * ```
-     */
-    leave(code: string): Promise<{
-        success: boolean;
-    }>;
-}