@xtr-dev/rondevu-client 0.12.4 → 0.17.0

package/dist/node-crypto-adapter.js

@@ -0,0 +1,80 @@
+/**
+ * Node.js Crypto adapter for Node.js environments
+ * Requires Node.js 19+ or Node.js 18 with --experimental-global-webcrypto flag
+ */
+import * as ed25519 from '@noble/ed25519';
+/**
+ * Node.js Crypto implementation using Node.js built-in APIs
+ * Uses Buffer for base64 encoding and crypto.randomBytes for random generation
+ *
+ * Requirements:
+ * - Node.js 19+ (crypto.subtle available globally)
+ * - OR Node.js 18 with --experimental-global-webcrypto flag
+ *
+ * @example
+ * ```typescript
+ * import { RondevuAPI } from '@xtr-dev/rondevu-client'
+ * import { NodeCryptoAdapter } from '@xtr-dev/rondevu-client/node'
+ *
+ * const api = new RondevuAPI(
+ *   'https://signal.example.com',
+ *   'alice',
+ *   keypair,
+ *   new NodeCryptoAdapter()
+ * )
+ * ```
+ */
+export class NodeCryptoAdapter {
+    constructor() {
+        // Set SHA-512 hash function for ed25519 using Node's crypto.subtle
+        if (typeof crypto === 'undefined' || !crypto.subtle) {
+            throw new Error('crypto.subtle is not available. ' +
+                'Node.js 19+ is required, or Node.js 18 with --experimental-global-webcrypto flag');
+        }
+        ed25519.hashes.sha512Async = async (message) => {
+            const hash = await crypto.subtle.digest('SHA-512', message);
+            return new Uint8Array(hash);
+        };
+    }
+    async generateKeypair() {
+        const privateKey = ed25519.utils.randomSecretKey();
+        const publicKey = await ed25519.getPublicKeyAsync(privateKey);
+        return {
+            publicKey: this.bytesToBase64(publicKey),
+            privateKey: this.bytesToBase64(privateKey),
+        };
+    }
+    async signMessage(message, privateKeyBase64) {
+        const privateKey = this.base64ToBytes(privateKeyBase64);
+        const encoder = new TextEncoder();
+        const messageBytes = encoder.encode(message);
+        const signature = await ed25519.signAsync(messageBytes, privateKey);
+        return this.bytesToBase64(signature);
+    }
+    async verifySignature(message, signatureBase64, publicKeyBase64) {
+        try {
+            const signature = this.base64ToBytes(signatureBase64);
+            const publicKey = this.base64ToBytes(publicKeyBase64);
+            const encoder = new TextEncoder();
+            const messageBytes = encoder.encode(message);
+            return await ed25519.verifyAsync(signature, messageBytes, publicKey);
+        }
+        catch {
+            return false;
+        }
+    }
+    bytesToBase64(bytes) {
+        // Node.js Buffer provides native base64 encoding
+        // @ts-expect-error - Buffer is available in Node.js but not in browser TypeScript definitions
+        return Buffer.from(bytes).toString('base64');
+    }
+    base64ToBytes(base64) {
+        // Node.js Buffer provides native base64 decoding
+        // @ts-expect-error - Buffer is available in Node.js but not in browser TypeScript definitions
+        return new Uint8Array(Buffer.from(base64, 'base64'));
+    }
+    randomBytes(length) {
+        // Use Web Crypto API's getRandomValues (available in Node 19+)
+        return crypto.getRandomValues(new Uint8Array(length));
+    }
+}

package/dist/rondevu-signaler.d.ts

@@ -1,6 +1,5 @@
-import { Signaler } from './types.js';
-import { RondevuService } from './rondevu-service.js';
-import { Binnable } from './bin.js';
+import { Signaler, Binnable } from './types.js';
+import { Rondevu } from './rondevu.js';
 export interface PollingConfig {
     initialInterval?: number;
     maxInterval?: number;
@@ -44,16 +43,17 @@ export declare class RondevuSignaler implements Signaler {
     private readonly service;
     private readonly host?;
     private offerId;
-    private serviceUuid;
+    private serviceFqn;
     private offerListeners;
     private answerListeners;
     private iceListeners;
-    private answerPollingTimeout;
+    private pollingTimeout;
     private icePollingTimeout;
-    private lastIceTimestamp;
+    private lastPollTimestamp;
     private isPolling;
+    private isOfferer;
     private pollingConfig;
-    constructor(rondevu: RondevuService, service: string, host?: string | undefined, pollingConfig?: PollingConfig);
+    constructor(rondevu: Rondevu, service: string, host?: string | undefined, pollingConfig?: PollingConfig);
     /**
      * Publish an offer as a service
      * Used by the offerer to make their offer available
@@ -88,15 +88,17 @@ export declare class RondevuSignaler implements Signaler {
      */
     private searchForOffer;
     /**
-     * Start polling for answer (offerer side) with exponential backoff
+     * Start combined polling for answers and ICE candidates (offerer side)
+     * Uses poll() for efficient batch polling
      */
-    private startAnswerPolling;
+    private startPolling;
     /**
-     * Stop polling for answer
+     * Stop combined polling
      */
-    private stopAnswerPolling;
+    private stopPolling;
     /**
-     * Start polling for ICE candidates with adaptive backoff
+     * Start polling for ICE candidates (answerer side only)
+     * Answerers use the separate endpoint since they don't have offers to poll
      */
     private startIcePolling;
     /**

package/dist/rondevu-signaler.js

@@ -35,14 +35,15 @@ export class RondevuSignaler {
         this.service = service;
         this.host = host;
         this.offerId = null;
-        this.serviceUuid = null;
+        this.serviceFqn = null;
         this.offerListeners = [];
         this.answerListeners = [];
         this.iceListeners = [];
-        this.answerPollingTimeout = null;
+        this.pollingTimeout = null;
         this.icePollingTimeout = null;
-        this.lastIceTimestamp = 0;
+        this.lastPollTimestamp = 0;
         this.isPolling = false;
+        this.isOfferer = false;
         this.pollingConfig = {
             initialInterval: pollingConfig?.initialInterval ?? 500,
             maxInterval: pollingConfig?.maxInterval ?? 5000,
@@ -64,18 +65,16 @@ export class RondevuSignaler {
             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();
+        this.serviceFqn = publishedService.serviceFqn;
+        this.isOfferer = true;
+        // Start combined polling for answers and ICE candidates
+        this.startPolling();
     }
     /**
      * Send an answer to the offerer
@@ -85,13 +84,13 @@ export class RondevuSignaler {
         if (!answer.sdp) {
             throw new Error('Answer SDP is required');
         }
-        if (!this.serviceUuid) {
-            throw new Error('No service UUID available. Must receive offer first.');
+        if (!this.serviceFqn || !this.offerId) {
+            throw new Error('No service FQN or offer ID available. Must receive offer first.');
         }
         // Send answer to the service
-        const result = await this.rondevu.getAPI().answerService(this.serviceUuid, answer.sdp);
-        this.offerId = result.offerId;
-        // Start polling for ICE candidates
+        await this.rondevu.getAPIPublic().answerOffer(this.serviceFqn, this.offerId, answer.sdp);
+        this.isOfferer = false;
+        // Start polling for ICE candidates (answerer uses separate endpoint)
         this.startIcePolling();
     }
     /**
@@ -130,8 +129,8 @@ export class RondevuSignaler {
      * Send an ICE candidate to the remote peer
      */
     async addIceCandidate(candidate) {
-        if (!this.serviceUuid) {
-            console.warn('Cannot send ICE candidate: no service UUID');
+        if (!this.serviceFqn || !this.offerId) {
+            console.warn('Cannot send ICE candidate: no service FQN or offer ID');
             return;
         }
         const candidateData = candidate.toJSON();
@@ -140,11 +139,7 @@ export class RondevuSignaler {
             return;
         }
         try {
-            const result = await this.rondevu.getAPI().addServiceIceCandidates(this.serviceUuid, [candidateData], this.offerId || undefined);
-            // Store offerId if we didn't have it yet
-            if (!this.offerId) {
-                this.offerId = result.offerId;
-            }
+            await this.rondevu.getAPIPublic().addOfferIceCandidates(this.serviceFqn, this.offerId, [candidateData]);
         }
         catch (err) {
             console.error('Failed to send ICE candidate:', err);
@@ -173,28 +168,21 @@ export class RondevuSignaler {
         }
         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}`);
+            // Get service by FQN (service should include @username)
+            const serviceFqn = `${this.service}@${this.host}`;
+            const serviceData = await this.rondevu.getAPIPublic().getService(serviceFqn);
+            if (!serviceData) {
+                console.warn(`No service found for ${serviceFqn}`);
                 this.isPolling = false;
                 return;
             }
-            const firstOffer = service.offers[0];
-            this.offerId = firstOffer.offerId;
-            this.serviceUuid = service.uuid;
+            // Store service details
+            this.offerId = serviceData.offerId;
+            this.serviceFqn = serviceData.serviceFqn;
             // Notify offer listeners
             const offer = {
                 type: 'offer',
-                sdp: firstOffer.sdp,
+                sdp: serviceData.sdp,
             };
             this.offerListeners.forEach(listener => {
                 try {
@@ -211,101 +199,129 @@ export class RondevuSignaler {
         }
     }
     /**
-     * Start polling for answer (offerer side) with exponential backoff
+     * Start combined polling for answers and ICE candidates (offerer side)
+     * Uses poll() for efficient batch polling
      */
-    startAnswerPolling() {
-        if (this.answerPollingTimeout || !this.serviceUuid) {
+    startPolling() {
+        if (this.pollingTimeout || !this.isOfferer) {
             return;
         }
         let interval = this.pollingConfig.initialInterval;
         let retries = 0;
+        let answerReceived = false;
         const poll = async () => {
-            if (!this.serviceUuid) {
-                this.stopAnswerPolling();
-                return;
-            }
             try {
-                const answer = await this.rondevu.getAPI().getServiceAnswer(this.serviceUuid);
-                if (answer && answer.sdp) {
-                    // Store offerId if we didn't have it yet
-                    if (!this.offerId) {
-                        this.offerId = answer.offerId;
+                const result = await this.rondevu.poll(this.lastPollTimestamp);
+                let foundActivity = false;
+                // Process answers
+                if (result.answers.length > 0 && !answerReceived) {
+                    foundActivity = true;
+                    // Find answer for our offerId
+                    const answer = result.answers.find(a => a.offerId === this.offerId);
+                    if (answer && answer.sdp) {
+                        answerReceived = true;
+                        const answerDesc = {
+                            type: 'answer',
+                            sdp: answer.sdp,
+                        };
+                        this.answerListeners.forEach(listener => {
+                            try {
+                                listener(answerDesc);
+                            }
+                            catch (err) {
+                                console.error('Answer listener error:', err);
+                            }
+                        });
+                        this.lastPollTimestamp = Math.max(this.lastPollTimestamp, answer.answeredAt);
                     }
-                    // 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);
+                }
+                // Process ICE candidates for our offer
+                if (this.offerId && result.iceCandidates[this.offerId]) {
+                    const candidates = result.iceCandidates[this.offerId];
+                    // Filter for answerer candidates (offerer receives answerer's candidates)
+                    const answererCandidates = candidates.filter(c => c.role === 'answerer');
+                    if (answererCandidates.length > 0) {
+                        foundActivity = true;
+                        for (const item of answererCandidates) {
+                            if (item.candidate && item.candidate.candidate && item.candidate.candidate !== '') {
+                                try {
+                                    const rtcCandidate = new RTCIceCandidate(item.candidate);
+                                    this.iceListeners.forEach(listener => {
+                                        try {
+                                            listener(rtcCandidate);
+                                        }
+                                        catch (err) {
+                                            console.error('ICE listener error:', err);
+                                        }
+                                    });
+                                    this.lastPollTimestamp = Math.max(this.lastPollTimestamp, item.createdAt);
+                                }
+                                catch (err) {
+                                    console.warn('Failed to process ICE candidate:', err);
+                                    this.lastPollTimestamp = Math.max(this.lastPollTimestamp, item.createdAt);
+                                }
+                            }
                         }
-                    });
-                    // 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;
+                // Adjust interval based on activity
+                if (foundActivity) {
+                    interval = this.pollingConfig.initialInterval;
+                    retries = 0;
+                }
+                else {
+                    retries++;
+                    if (retries > this.pollingConfig.maxRetries) {
+                        console.warn('Max retries reached for polling');
+                        this.stopPolling();
+                        return;
+                    }
+                    interval = Math.min(interval * this.pollingConfig.backoffMultiplier, this.pollingConfig.maxInterval);
                 }
-                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);
+                this.pollingTimeout = 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);
-                }
+                console.error('Error polling offers:', err);
                 // Retry with backoff
                 const finalInterval = this.pollingConfig.jitter
                     ? interval + Math.random() * 100
                     : interval;
-                this.answerPollingTimeout = setTimeout(poll, finalInterval);
+                this.pollingTimeout = setTimeout(poll, finalInterval);
             }
         };
         poll(); // Start immediately
     }
     /**
-     * Stop polling for answer
+     * Stop combined polling
      */
-    stopAnswerPolling() {
-        if (this.answerPollingTimeout) {
-            clearTimeout(this.answerPollingTimeout);
-            this.answerPollingTimeout = null;
+    stopPolling() {
+        if (this.pollingTimeout) {
+            clearTimeout(this.pollingTimeout);
+            this.pollingTimeout = null;
         }
     }
     /**
-     * Start polling for ICE candidates with adaptive backoff
+     * Start polling for ICE candidates (answerer side only)
+     * Answerers use the separate endpoint since they don't have offers to poll
      */
     startIcePolling() {
-        if (this.icePollingTimeout || !this.serviceUuid) {
+        if (this.icePollingTimeout || !this.serviceFqn || !this.offerId || this.isOfferer) {
             return;
         }
         let interval = this.pollingConfig.initialInterval;
         const poll = async () => {
-            if (!this.serviceUuid) {
+            if (!this.serviceFqn || !this.offerId) {
                 this.stopIcePolling();
                 return;
             }
             try {
                 const result = await this.rondevu
-                    .getAPI()
-                    .getServiceIceCandidates(this.serviceUuid, this.lastIceTimestamp, this.offerId || undefined);
-                // Store offerId if we didn't have it yet
-                if (!this.offerId) {
-                    this.offerId = result.offerId;
-                }
+                    .getAPIPublic()
+                    .getOfferIceCandidates(this.serviceFqn, this.offerId, this.lastPollTimestamp);
                 let foundCandidates = false;
                 for (const item of result.candidates) {
                     if (item.candidate && item.candidate.candidate && item.candidate.candidate !== '') {
@@ -320,15 +336,15 @@ export class RondevuSignaler {
                                     console.error('ICE listener error:', err);
                                 }
                             });
-                            this.lastIceTimestamp = item.createdAt;
+                            this.lastPollTimestamp = item.createdAt;
                         }
                         catch (err) {
                             console.warn('Failed to process ICE candidate:', err);
-                            this.lastIceTimestamp = item.createdAt;
+                            this.lastPollTimestamp = item.createdAt;
                         }
                     }
                     else {
-                        this.lastIceTimestamp = item.createdAt;
+                        this.lastPollTimestamp = item.createdAt;
                     }
                 }
                 // If candidates found, reset interval to initial value
@@ -376,7 +392,7 @@ export class RondevuSignaler {
      * Stop all polling and cleanup
      */
     dispose() {
-        this.stopAnswerPolling();
+        this.stopPolling();
         this.stopIcePolling();
         this.offerListeners = [];
         this.answerListeners = [];