@xtr-dev/rondevu-client 0.3.5 → 0.4.0

package/dist/connection.js

@@ -1,280 +1,283 @@
-import { EventEmitter } from './event-emitter.js';
 /**
- * Represents a WebRTC connection with automatic signaling and ICE exchange
+ * High-level WebRTC connection manager for Rondevu
+ * Handles offer/answer exchange, ICE candidates, and connection lifecycle
  */
-export class RondevuConnection extends EventEmitter {
-    constructor(params, client) {
-        super();
-        this.isPolling = false;
-        this.isClosed = false;
-        this.hasConnected = false;
-        this.id = params.id;
-        this.role = params.role;
-        this.pc = params.pc;
-        this.localPeerId = params.localPeerId;
-        this.remotePeerId = params.remotePeerId;
-        this.client = client;
-        this.dataChannels = new Map();
-        this.pollingIntervalMs = params.pollingInterval;
-        this.connectionTimeoutMs = params.connectionTimeout;
-        this.wrtc = params.wrtc;
-        // Use injected WebRTC polyfill or fall back to global
-        this.RTCIceCandidate = params.wrtc?.RTCIceCandidate || globalThis.RTCIceCandidate;
-        this.setupEventHandlers();
-        this.startConnectionTimeout();
+export class RondevuConnection {
+    /**
+     * Current connection state
+     */
+    get connectionState() {
+        return this.pc.connectionState;
+    }
+    /**
+     * The offer ID for this connection
+     */
+    get id() {
+        return this.offerId;
     }
     /**
-     * Setup RTCPeerConnection event handlers
+     * Get the primary data channel (if created)
      */
-    setupEventHandlers() {
-        // ICE candidate gathering
-        this.pc.onicecandidate = (event) => {
-            if (event.candidate && !this.isClosed) {
-                this.sendIceCandidate(event.candidate).catch((err) => {
-                    this.emit('error', new Error(`Failed to send ICE candidate: ${err.message}`));
-                });
+    get channel() {
+        return this.dataChannel;
+    }
+    constructor(offersApi, rtcConfig = {
+        iceServers: [
+            { urls: 'stun:stun.l.google.com:19302' },
+            { urls: 'stun:stun1.l.google.com:19302' }
+        ]
+    }) {
+        this.rtcConfig = rtcConfig;
+        this.lastIceTimestamp = Date.now();
+        this.eventListeners = new Map();
+        this.pendingIceCandidates = [];
+        this.offersApi = offersApi;
+        this.pc = new RTCPeerConnection(rtcConfig);
+        this.setupPeerConnection();
+    }
+    /**
+     * Set up peer connection event handlers
+     */
+    setupPeerConnection() {
+        this.pc.onicecandidate = async (event) => {
+            if (event.candidate) {
+                // Convert RTCIceCandidate to RTCIceCandidateInit (plain object)
+                const candidateData = {
+                    candidate: event.candidate.candidate,
+                    sdpMid: event.candidate.sdpMid,
+                    sdpMLineIndex: event.candidate.sdpMLineIndex,
+                    usernameFragment: event.candidate.usernameFragment,
+                };
+                if (this.offerId) {
+                    // offerId is set, send immediately (trickle ICE)
+                    try {
+                        await this.offersApi.addIceCandidates(this.offerId, [candidateData]);
+                    }
+                    catch (err) {
+                        console.error('Error sending ICE candidate:', err);
+                    }
+                }
+                else {
+                    // offerId not set yet, buffer the candidate
+                    this.pendingIceCandidates.push(candidateData);
+                }
             }
         };
-        // Connection state changes
         this.pc.onconnectionstatechange = () => {
-            this.handleConnectionStateChange();
+            switch (this.pc.connectionState) {
+                case 'connecting':
+                    this.emit('connecting');
+                    break;
+                case 'connected':
+                    this.emit('connected');
+                    // Stop polling once connected - we have all the ICE candidates we need
+                    this.stopPolling();
+                    break;
+                case 'disconnected':
+                case 'failed':
+                case 'closed':
+                    this.emit('disconnected');
+                    this.stopPolling();
+                    break;
+            }
         };
-        // Remote data channels
         this.pc.ondatachannel = (event) => {
-            this.handleRemoteDataChannel(event.channel);
+            this.dataChannel = event.channel;
+            this.emit('datachannel', event.channel);
         };
-        // Remote media streams
         this.pc.ontrack = (event) => {
-            if (event.streams && event.streams[0]) {
-                this.emit('stream', event.streams[0]);
-            }
+            this.emit('track', event);
         };
-        // ICE connection state changes
-        this.pc.oniceconnectionstatechange = () => {
-            const state = this.pc.iceConnectionState;
-            if (state === 'failed' || state === 'closed') {
-                this.emit('error', new Error(`ICE connection ${state}`));
-                if (state === 'failed') {
-                    this.close();
-                }
-            }
+        this.pc.onicecandidateerror = (event) => {
+            console.error('ICE candidate error:', event);
         };
     }
     /**
-     * Handle RTCPeerConnection state changes
+     * Flush buffered ICE candidates (trickle ICE support)
      */
-    handleConnectionStateChange() {
-        const state = this.pc.connectionState;
-        switch (state) {
-            case 'connected':
-                if (!this.hasConnected) {
-                    this.hasConnected = true;
-                    this.clearConnectionTimeout();
-                    this.stopPolling();
-                    this.emit('connect');
-                }
-                break;
-            case 'disconnected':
-                this.emit('disconnect');
-                break;
-            case 'failed':
-                this.emit('error', new Error('Connection failed'));
-                this.close();
-                break;
-            case 'closed':
-                this.emit('disconnect');
-                break;
+    async flushPendingIceCandidates() {
+        if (this.pendingIceCandidates.length > 0 && this.offerId) {
+            try {
+                await this.offersApi.addIceCandidates(this.offerId, this.pendingIceCandidates);
+                this.pendingIceCandidates = [];
+            }
+            catch (err) {
+                console.error('Error flushing pending ICE candidates:', err);
+            }
         }
     }
     /**
-     * Send an ICE candidate to the remote peer via signaling server
+     * Create an offer and advertise on topics
      */
-    async sendIceCandidate(candidate) {
-        try {
-            await this.client.sendAnswer({
-                code: this.id,
-                candidate: JSON.stringify(candidate.toJSON()),
-                side: this.role,
-            });
-        }
-        catch (err) {
-            throw new Error(`Failed to send ICE candidate: ${err.message}`);
+    async createOffer(options) {
+        this.role = 'offerer';
+        // Create data channel if requested
+        if (options.createDataChannel !== false) {
+            this.dataChannel = this.pc.createDataChannel(options.dataChannelLabel || 'data');
+            this.emit('datachannel', this.dataChannel);
         }
+        // Create WebRTC offer
+        const offer = await this.pc.createOffer();
+        await this.pc.setLocalDescription(offer);
+        // Create offer on Rondevu server
+        const offers = await this.offersApi.create([{
+                sdp: offer.sdp,
+                topics: options.topics,
+                ttl: options.ttl || 300000
+            }]);
+        this.offerId = offers[0].id;
+        // Flush any ICE candidates that were generated during offer creation
+        await this.flushPendingIceCandidates();
+        // Start polling for answers
+        this.startAnswerPolling();
+        return this.offerId;
     }
     /**
-     * Start polling for remote session data (answer/candidates)
+     * Answer an existing offer
      */
-    startPolling() {
-        if (this.isPolling || this.isClosed) {
-            return;
-        }
-        this.isPolling = true;
-        // Poll immediately
-        this.poll().catch((err) => {
-            this.emit('error', new Error(`Poll error: ${err.message}`));
+    async answer(offerId, offerSdp) {
+        this.role = 'answerer';
+        // Set remote description
+        await this.pc.setRemoteDescription({
+            type: 'offer',
+            sdp: offerSdp
         });
-        // Set up interval polling
-        this.pollingInterval = setInterval(() => {
-            this.poll().catch((err) => {
-                this.emit('error', new Error(`Poll error: ${err.message}`));
-            });
-        }, this.pollingIntervalMs);
-    }
-    /**
-     * Stop polling
-     */
-    stopPolling() {
-        this.isPolling = false;
-        if (this.pollingInterval) {
-            clearInterval(this.pollingInterval);
-            this.pollingInterval = undefined;
-        }
+        // Create answer
+        const answer = await this.pc.createAnswer();
+        await this.pc.setLocalDescription(answer);
+        // Send answer to server FIRST
+        // This registers us as the answerer before ICE candidates arrive
+        await this.offersApi.answer(offerId, answer.sdp);
+        // Now set offerId to enable ICE candidate sending
+        // This prevents a race condition where ICE candidates arrive before answer is registered
+        this.offerId = offerId;
+        // Flush any ICE candidates that were generated during answer creation
+        await this.flushPendingIceCandidates();
+        // Start polling for ICE candidates
+        this.startIcePolling();
     }
     /**
-     * Poll the signaling server for remote data
+     * Start polling for answers (offerer only)
      */
-    async poll() {
-        if (this.isClosed) {
-            this.stopPolling();
+    startAnswerPolling() {
+        if (this.role !== 'offerer' || !this.offerId)
             return;
-        }
-        try {
-            const response = await this.client.poll(this.id, this.role);
-            if (this.role === 'offerer') {
-                const offererResponse = response;
-                // Apply answer if received and not yet applied
-                if (offererResponse.answer && !this.pc.currentRemoteDescription) {
+        this.answerPollingInterval = setInterval(async () => {
+            try {
+                const answers = await this.offersApi.getAnswers();
+                const myAnswer = answers.find(a => a.offerId === this.offerId);
+                if (myAnswer) {
+                    // Set remote description
                     await this.pc.setRemoteDescription({
                         type: 'answer',
-                        sdp: offererResponse.answer,
+                        sdp: myAnswer.sdp
                     });
+                    // Stop answer polling, start ICE polling
+                    this.stopAnswerPolling();
+                    this.startIcePolling();
                 }
-                // Apply ICE candidates
-                if (offererResponse.answerCandidates && offererResponse.answerCandidates.length > 0) {
-                    for (const candidateStr of offererResponse.answerCandidates) {
-                        try {
-                            const candidate = JSON.parse(candidateStr);
-                            await this.pc.addIceCandidate(new this.RTCIceCandidate(candidate));
-                        }
-                        catch (err) {
-                            console.warn('Failed to add ICE candidate:', err);
-                        }
-                    }
+            }
+            catch (err) {
+                console.error('Error polling for answers:', err);
+                // Stop polling if offer expired/not found
+                if (err instanceof Error && err.message.includes('not found')) {
+                    this.stopPolling();
                 }
             }
-            else {
-                // Answerer role
-                const answererResponse = response;
-                // Apply ICE candidates from offerer
-                if (answererResponse.offerCandidates && answererResponse.offerCandidates.length > 0) {
-                    for (const candidateStr of answererResponse.offerCandidates) {
-                        try {
-                            const candidate = JSON.parse(candidateStr);
-                            await this.pc.addIceCandidate(new this.RTCIceCandidate(candidate));
-                        }
-                        catch (err) {
-                            console.warn('Failed to add ICE candidate:', err);
-                        }
-                    }
+        }, 2000);
+    }
+    /**
+     * Start polling for ICE candidates
+     */
+    startIcePolling() {
+        if (!this.offerId)
+            return;
+        this.icePollingInterval = setInterval(async () => {
+            if (!this.offerId)
+                return;
+            try {
+                const candidates = await this.offersApi.getIceCandidates(this.offerId, this.lastIceTimestamp);
+                for (const cand of candidates) {
+                    // Use the candidate object directly - it's already RTCIceCandidateInit
+                    await this.pc.addIceCandidate(new RTCIceCandidate(cand.candidate));
+                    this.lastIceTimestamp = cand.createdAt;
                 }
             }
-        }
-        catch (err) {
-            // Session not found or expired
-            if (err.message.includes('404') || err.message.includes('not found')) {
-                this.emit('error', new Error('Session not found or expired'));
-                this.close();
+            catch (err) {
+                console.error('Error polling for ICE candidates:', err);
+                // Stop polling if offer expired/not found
+                if (err instanceof Error && err.message.includes('not found')) {
+                    this.stopPolling();
+                }
             }
-            throw err;
-        }
+        }, 1000);
     }
     /**
-     * Handle remotely created data channel
+     * Stop answer polling
      */
-    handleRemoteDataChannel(channel) {
-        this.dataChannels.set(channel.label, channel);
-        this.emit('datachannel', channel);
+    stopAnswerPolling() {
+        if (this.answerPollingInterval) {
+            clearInterval(this.answerPollingInterval);
+            this.answerPollingInterval = undefined;
+        }
     }
     /**
-     * Get or create a data channel
+     * Stop ICE polling
      */
-    dataChannel(label, options) {
-        let channel = this.dataChannels.get(label);
-        if (!channel) {
-            channel = this.pc.createDataChannel(label, options);
-            this.dataChannels.set(label, channel);
+    stopIcePolling() {
+        if (this.icePollingInterval) {
+            clearInterval(this.icePollingInterval);
+            this.icePollingInterval = undefined;
         }
-        return channel;
     }
     /**
-     * Add a local media stream to the connection
+     * Stop all polling
      */
-    addStream(stream) {
-        stream.getTracks().forEach(track => {
-            this.pc.addTrack(track, stream);
-        });
+    stopPolling() {
+        this.stopAnswerPolling();
+        this.stopIcePolling();
     }
     /**
-     * Get the underlying RTCPeerConnection for advanced usage
+     * Add event listener
      */
-    getPeerConnection() {
-        return this.pc;
+    on(event, listener) {
+        if (!this.eventListeners.has(event)) {
+            this.eventListeners.set(event, new Set());
+        }
+        this.eventListeners.get(event).add(listener);
     }
     /**
-     * Start connection timeout
+     * Remove event listener
      */
-    startConnectionTimeout() {
-        this.connectionTimer = setTimeout(() => {
-            if (this.pc.connectionState !== 'connected') {
-                this.emit('error', new Error('Connection timeout'));
-                this.close();
-            }
-        }, this.connectionTimeoutMs);
+    off(event, listener) {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+            listeners.delete(listener);
+        }
     }
     /**
-     * Clear connection timeout
+     * Emit event
      */
-    clearConnectionTimeout() {
-        if (this.connectionTimer) {
-            clearTimeout(this.connectionTimer);
-            this.connectionTimer = undefined;
+    emit(event, ...args) {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+            listeners.forEach(listener => {
+                listener(...args);
+            });
         }
     }
     /**
-     * Leave the session by deleting the offer on the server and closing the connection
-     * This ends the session for all connected peers
+     * Add a media track to the connection
      */
-    async leave() {
-        try {
-            await this.client.leave(this.id);
-        }
-        catch (err) {
-            // Ignore errors - session might already be expired
-            console.debug('Leave error (ignored):', err);
-        }
-        this.close();
+    addTrack(track, ...streams) {
+        return this.pc.addTrack(track, ...streams);
     }
     /**
-     * Close the connection and cleanup resources
+     * Close the connection and clean up
      */
     close() {
-        if (this.isClosed) {
-            return;
-        }
-        this.isClosed = true;
         this.stopPolling();
-        this.clearConnectionTimeout();
-        // Close all data channels
-        this.dataChannels.forEach(dc => {
-            if (dc.readyState === 'open' || dc.readyState === 'connecting') {
-                dc.close();
-            }
-        });
-        this.dataChannels.clear();
-        // Close peer connection
-        if (this.pc.connectionState !== 'closed') {
-            this.pc.close();
-        }
-        this.emit('disconnect');
+        this.pc.close();
+        this.eventListeners.clear();
     }
 }

package/dist/index.d.ts

@@ -1,8 +1,13 @@
 /**
  * @xtr-dev/rondevu-client
- * WebRTC peer signaling and discovery client
+ * WebRTC peer signaling and discovery client with topic-based discovery
  */
 export { Rondevu } from './rondevu.js';
+export type { RondevuOptions } from './rondevu.js';
+export { RondevuAuth } from './auth.js';
+export type { Credentials, FetchFunction } from './auth.js';
+export { RondevuOffers } from './offers.js';
+export type { CreateOfferRequest, Offer, IceCandidate, TopicInfo } from './offers.js';
+export { BloomFilter } from './bloom.js';
 export { RondevuConnection } from './connection.js';
-export { RondevuAPI } from './client.js';
-export type { RondevuOptions, ConnectionRole, RondevuConnectionParams, RondevuConnectionEvents, WebRTCPolyfill, Side, CreateOfferRequest, CreateOfferResponse, AnswerRequest, AnswerResponse, PollRequest, PollOffererResponse, PollAnswererResponse, PollResponse, VersionResponse, HealthResponse, ErrorResponse, RondevuClientOptions, } from './types.js';
+export type { ConnectionOptions, RondevuConnectionEvents } from './connection.js';

package/dist/index.js

@@ -1,10 +1,14 @@
 /**
  * @xtr-dev/rondevu-client
- * WebRTC peer signaling and discovery client
+ * WebRTC peer signaling and discovery client with topic-based discovery
  */
-// Export main WebRTC client class
+// Export main client class
 export { Rondevu } from './rondevu.js';
-// Export connection class
+// Export authentication
+export { RondevuAuth } from './auth.js';
+// Export offers API
+export { RondevuOffers } from './offers.js';
+// Export bloom filter
+export { BloomFilter } from './bloom.js';
+// Export connection manager
 export { RondevuConnection } from './connection.js';
-// Export low-level signaling API (for advanced usage)
-export { RondevuAPI } from './client.js';

package/dist/offers.d.ts

@@ -0,0 +1,108 @@
+import { Credentials, FetchFunction } from './auth.js';
+export interface CreateOfferRequest {
+    id?: string;
+    sdp: string;
+    topics: string[];
+    ttl?: number;
+}
+export interface Offer {
+    id: string;
+    peerId: string;
+    sdp: string;
+    topics: string[];
+    createdAt?: number;
+    expiresAt: number;
+    lastSeen: number;
+    answererPeerId?: string;
+    answerSdp?: string;
+    answeredAt?: number;
+}
+/**
+ * RTCIceCandidateInit interface for environments without native WebRTC types
+ */
+export interface RTCIceCandidateInit {
+    candidate?: string;
+    sdpMid?: string | null;
+    sdpMLineIndex?: number | null;
+    usernameFragment?: string | null;
+}
+export interface IceCandidate {
+    candidate: RTCIceCandidateInit;
+    peerId: string;
+    role: 'offerer' | 'answerer';
+    createdAt: number;
+}
+export interface TopicInfo {
+    topic: string;
+    activePeers: number;
+}
+export declare class RondevuOffers {
+    private baseUrl;
+    private credentials;
+    private fetchFn;
+    constructor(baseUrl: string, credentials: Credentials, fetchFn?: FetchFunction);
+    /**
+     * Create one or more offers
+     */
+    create(offers: CreateOfferRequest[]): Promise<Offer[]>;
+    /**
+     * Find offers by topic with optional bloom filter
+     */
+    findByTopic(topic: string, options?: {
+        bloomFilter?: Uint8Array;
+        limit?: number;
+    }): Promise<Offer[]>;
+    /**
+     * Get all offers from a specific peer
+     */
+    getByPeerId(peerId: string): Promise<{
+        offers: Offer[];
+        topics: string[];
+    }>;
+    /**
+     * Get topics with active peer counts (paginated)
+     */
+    getTopics(options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        topics: TopicInfo[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    /**
+     * Get own offers
+     */
+    getMine(): Promise<Offer[]>;
+    /**
+     * Update offer heartbeat
+     */
+    heartbeat(offerId: string): Promise<void>;
+    /**
+     * Delete an offer
+     */
+    delete(offerId: string): Promise<void>;
+    /**
+     * Answer an offer
+     */
+    answer(offerId: string, sdp: string): Promise<void>;
+    /**
+     * Get answers to your offers
+     */
+    getAnswers(): Promise<Array<{
+        offerId: string;
+        answererId: string;
+        sdp: string;
+        answeredAt: number;
+        topics: string[];
+    }>>;
+    /**
+     * Post ICE candidates for an offer
+     */
+    addIceCandidates(offerId: string, candidates: RTCIceCandidateInit[]): Promise<void>;
+    /**
+     * Get ICE candidates for an offer
+     */
+    getIceCandidates(offerId: string, since?: number): Promise<IceCandidate[]>;
+}