@xtr-dev/rondevu-client 0.7.12 → 0.8.0

package/dist/discovery.d.ts

@@ -0,0 +1,93 @@
+import RondevuPeer from './peer/index.js';
+/**
+ * Service info from discovery
+ */
+export interface ServiceInfo {
+    uuid: string;
+    isPublic: boolean;
+    serviceFqn?: string;
+    metadata?: Record<string, any>;
+}
+/**
+ * Service list result
+ */
+export interface ServiceListResult {
+    username: string;
+    services: ServiceInfo[];
+}
+/**
+ * Service query result
+ */
+export interface ServiceQueryResult {
+    uuid: string;
+    allowed: boolean;
+}
+/**
+ * Service details
+ */
+export interface ServiceDetails {
+    serviceId: string;
+    username: string;
+    serviceFqn: string;
+    offerId: string;
+    sdp: string;
+    isPublic: boolean;
+    metadata?: Record<string, any>;
+    createdAt: number;
+    expiresAt: number;
+}
+/**
+ * Connect result
+ */
+export interface ConnectResult {
+    peer: RondevuPeer;
+    channel: RTCDataChannel;
+}
+/**
+ * Rondevu Discovery API
+ * Handles service discovery and connections
+ */
+export declare class RondevuDiscovery {
+    private baseUrl;
+    private credentials;
+    private offersApi;
+    constructor(baseUrl: string, credentials: {
+        peerId: string;
+        secret: string;
+    });
+    /**
+     * Lists all services for a username
+     * Returns UUIDs only for private services, full details for public
+     */
+    listServices(username: string): Promise<ServiceListResult>;
+    /**
+     * Queries a service by FQN
+     * Returns UUID if service exists and is allowed
+     */
+    queryService(username: string, serviceFqn: string): Promise<ServiceQueryResult>;
+    /**
+     * Gets service details by UUID
+     */
+    getServiceDetails(uuid: string): Promise<ServiceDetails>;
+    /**
+     * Connects to a service by UUID
+     */
+    connectToService(uuid: string, options?: {
+        rtcConfig?: RTCConfiguration;
+        onConnected?: () => void;
+        onData?: (data: any) => void;
+    }): Promise<RondevuPeer>;
+    /**
+     * Convenience method: Query and connect in one call
+     * Returns both peer and data channel
+     */
+    connect(username: string, serviceFqn: string, options?: {
+        rtcConfig?: RTCConfiguration;
+    }): Promise<ConnectResult>;
+    /**
+     * Convenience method: Connect to service by UUID with channel
+     */
+    connectByUuid(uuid: string, options?: {
+        rtcConfig?: RTCConfiguration;
+    }): Promise<ConnectResult>;
+}

package/dist/discovery.js

@@ -0,0 +1,164 @@
+import RondevuPeer from './peer/index.js';
+import { RondevuOffers } from './offers.js';
+/**
+ * Rondevu Discovery API
+ * Handles service discovery and connections
+ */
+export class RondevuDiscovery {
+    constructor(baseUrl, credentials) {
+        this.baseUrl = baseUrl;
+        this.credentials = credentials;
+        this.offersApi = new RondevuOffers(baseUrl, credentials);
+    }
+    /**
+     * Lists all services for a username
+     * Returns UUIDs only for private services, full details for public
+     */
+    async listServices(username) {
+        const response = await fetch(`${this.baseUrl}/usernames/${username}/services`);
+        if (!response.ok) {
+            throw new Error('Failed to list services');
+        }
+        const data = await response.json();
+        return {
+            username: data.username,
+            services: data.services
+        };
+    }
+    /**
+     * Queries a service by FQN
+     * Returns UUID if service exists and is allowed
+     */
+    async queryService(username, serviceFqn) {
+        const response = await fetch(`${this.baseUrl}/index/${username}/query`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ serviceFqn })
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(error.error || 'Service not found');
+        }
+        const data = await response.json();
+        return {
+            uuid: data.uuid,
+            allowed: data.allowed
+        };
+    }
+    /**
+     * Gets service details by UUID
+     */
+    async getServiceDetails(uuid) {
+        const response = await fetch(`${this.baseUrl}/services/${uuid}`);
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(error.error || 'Service not found');
+        }
+        const data = await response.json();
+        return {
+            serviceId: data.serviceId,
+            username: data.username,
+            serviceFqn: data.serviceFqn,
+            offerId: data.offerId,
+            sdp: data.sdp,
+            isPublic: data.isPublic,
+            metadata: data.metadata,
+            createdAt: data.createdAt,
+            expiresAt: data.expiresAt
+        };
+    }
+    /**
+     * Connects to a service by UUID
+     */
+    async connectToService(uuid, options) {
+        // Get service details
+        const service = await this.getServiceDetails(uuid);
+        // Create peer with the offer
+        const peer = new RondevuPeer(this.offersApi, options?.rtcConfig || {
+            iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
+        });
+        // Set up event handlers
+        if (options?.onConnected) {
+            peer.on('connected', options.onConnected);
+        }
+        if (options?.onData) {
+            peer.on('datachannel', (channel) => {
+                channel.onmessage = (e) => options.onData(e.data);
+            });
+        }
+        // Answer the offer
+        await peer.answer(service.offerId, service.sdp, {
+            topics: [], // V2 doesn't use topics
+            rtcConfig: options?.rtcConfig
+        });
+        return peer;
+    }
+    /**
+     * Convenience method: Query and connect in one call
+     * Returns both peer and data channel
+     */
+    async connect(username, serviceFqn, options) {
+        // Query service
+        const query = await this.queryService(username, serviceFqn);
+        if (!query.allowed) {
+            throw new Error('Service access denied');
+        }
+        // Get service details
+        const service = await this.getServiceDetails(query.uuid);
+        // Create peer
+        const peer = new RondevuPeer(this.offersApi, options?.rtcConfig || {
+            iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
+        });
+        // Answer the offer
+        await peer.answer(service.offerId, service.sdp, {
+            topics: [], // V2 doesn't use topics
+            rtcConfig: options?.rtcConfig
+        });
+        // Wait for data channel
+        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);
+            });
+            peer.on('failed', (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            });
+        });
+        return { peer, channel };
+    }
+    /**
+     * Convenience method: Connect to service by UUID with channel
+     */
+    async connectByUuid(uuid, options) {
+        // Get service details
+        const service = await this.getServiceDetails(uuid);
+        // Create peer
+        const peer = new RondevuPeer(this.offersApi, options?.rtcConfig || {
+            iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
+        });
+        // Answer the offer
+        await peer.answer(service.offerId, service.sdp, {
+            topics: [], // V2 doesn't use topics
+            rtcConfig: options?.rtcConfig
+        });
+        // Wait for data channel
+        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);
+            });
+            peer.on('failed', (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            });
+        });
+        return { peer, channel };
+    }
+}

package/dist/index.d.ts

@@ -8,6 +8,5 @@ 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 { default as RondevuPeer } from './peer/index.js';
 export type { PeerOptions, PeerEvents, PeerTimeouts } from './peer/index.js';

package/dist/index.js

@@ -8,7 +8,5 @@ export { Rondevu } from './rondevu.js';
 export { RondevuAuth } from './auth.js';
 // Export offers API
 export { RondevuOffers } from './offers.js';
-// Export bloom filter
-export { BloomFilter } from './bloom.js';
 // Export peer manager
 export { default as RondevuPeer } from './peer/index.js';

package/dist/offer-pool.d.ts

@@ -0,0 +1,74 @@
+import { RondevuOffers, Offer } from './offers.js';
+/**
+ * Represents an offer that has been answered
+ */
+export interface AnsweredOffer {
+    offerId: string;
+    answererId: string;
+    sdp: string;
+    answeredAt: number;
+}
+/**
+ * Configuration options for the offer pool
+ */
+export interface OfferPoolOptions {
+    /** Number of simultaneous open offers to maintain */
+    poolSize: number;
+    /** Polling interval in milliseconds (default: 2000ms) */
+    pollingInterval?: number;
+    /** Callback invoked when an offer is answered */
+    onAnswered: (answer: AnsweredOffer) => Promise<void>;
+    /** Callback to create new offers when refilling the pool */
+    onRefill: (count: number) => Promise<Offer[]>;
+    /** Error handler for pool operations */
+    onError: (error: Error, context: string) => void;
+}
+/**
+ * Manages a pool of offers with automatic polling and refill
+ *
+ * The OfferPool maintains a configurable number of simultaneous offers,
+ * polls for answers periodically, and automatically refills the pool
+ * when offers are consumed.
+ */
+export declare class OfferPool {
+    private offersApi;
+    private options;
+    private offers;
+    private polling;
+    private pollingTimer?;
+    private lastPollTime;
+    private readonly pollingInterval;
+    constructor(offersApi: RondevuOffers, options: OfferPoolOptions);
+    /**
+     * Add offers to the pool
+     */
+    addOffers(offers: Offer[]): Promise<void>;
+    /**
+     * Start polling for answers
+     */
+    start(): Promise<void>;
+    /**
+     * Stop polling for answers
+     */
+    stop(): Promise<void>;
+    /**
+     * Poll for answers and refill the pool if needed
+     */
+    private poll;
+    /**
+     * Get the current number of active offers in the pool
+     */
+    getActiveOfferCount(): number;
+    /**
+     * Get all active offer IDs
+     */
+    getActiveOfferIds(): string[];
+    /**
+     * Get the last poll timestamp
+     */
+    getLastPollTime(): number;
+    /**
+     * Check if the pool is currently polling
+     */
+    isPolling(): boolean;
+}

package/dist/offer-pool.js

@@ -0,0 +1,119 @@
+/**
+ * Manages a pool of offers with automatic polling and refill
+ *
+ * The OfferPool maintains a configurable number of simultaneous offers,
+ * polls for answers periodically, and automatically refills the pool
+ * when offers are consumed.
+ */
+export class OfferPool {
+    constructor(offersApi, options) {
+        this.offersApi = offersApi;
+        this.options = options;
+        this.offers = new Map();
+        this.polling = false;
+        this.lastPollTime = 0;
+        this.pollingInterval = options.pollingInterval || 2000;
+    }
+    /**
+     * Add offers to the pool
+     */
+    async addOffers(offers) {
+        for (const offer of offers) {
+            this.offers.set(offer.id, offer);
+        }
+    }
+    /**
+     * Start polling for answers
+     */
+    async start() {
+        if (this.polling) {
+            return;
+        }
+        this.polling = true;
+        // Do an immediate poll
+        await this.poll().catch((error) => {
+            this.options.onError(error, 'initial-poll');
+        });
+        // Start polling interval
+        this.pollingTimer = setInterval(async () => {
+            if (this.polling) {
+                await this.poll().catch((error) => {
+                    this.options.onError(error, 'poll');
+                });
+            }
+        }, this.pollingInterval);
+    }
+    /**
+     * Stop polling for answers
+     */
+    async stop() {
+        this.polling = false;
+        if (this.pollingTimer) {
+            clearInterval(this.pollingTimer);
+            this.pollingTimer = undefined;
+        }
+    }
+    /**
+     * Poll for answers and refill the pool if needed
+     */
+    async poll() {
+        try {
+            // Get all answers from server
+            const answers = await this.offersApi.getAnswers();
+            // Filter for our pool's offers
+            const myAnswers = answers.filter(a => this.offers.has(a.offerId));
+            // Process each answer
+            for (const answer of myAnswers) {
+                // Notify ServicePool
+                await this.options.onAnswered({
+                    offerId: answer.offerId,
+                    answererId: answer.answererId,
+                    sdp: answer.sdp,
+                    answeredAt: answer.answeredAt
+                });
+                // Remove consumed offer from pool
+                this.offers.delete(answer.offerId);
+            }
+            // Immediate refill if below pool size
+            if (this.offers.size < this.options.poolSize) {
+                const needed = this.options.poolSize - this.offers.size;
+                try {
+                    const newOffers = await this.options.onRefill(needed);
+                    await this.addOffers(newOffers);
+                }
+                catch (refillError) {
+                    this.options.onError(refillError, 'refill');
+                }
+            }
+            this.lastPollTime = Date.now();
+        }
+        catch (error) {
+            // Don't crash the pool on errors - let error handler deal with it
+            this.options.onError(error, 'poll');
+        }
+    }
+    /**
+     * Get the current number of active offers in the pool
+     */
+    getActiveOfferCount() {
+        return this.offers.size;
+    }
+    /**
+     * Get all active offer IDs
+     */
+    getActiveOfferIds() {
+        return Array.from(this.offers.keys());
+    }
+    /**
+     * Get the last poll timestamp
+     */
+    getLastPollTime() {
+        return this.lastPollTime;
+    }
+    /**
+     * Check if the pool is currently polling
+     */
+    isPolling() {
+        return this.polling;
+    }
+}

package/dist/rondevu.d.ts

@@ -1,5 +1,8 @@
 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';
 export interface RondevuOptions {
     /**
@@ -58,7 +61,10 @@ export interface RondevuOptions {
 }
 export declare class Rondevu {
     readonly auth: RondevuAuth;
+    readonly usernames: RondevuUsername;
     private _offers?;
+    private _services?;
+    private _discovery?;
     private credentials?;
     private baseUrl;
     private fetchFn?;
@@ -67,9 +73,18 @@ export declare class Rondevu {
     private rtcIceCandidate?;
     constructor(options?: RondevuOptions);
     /**
-     * Get offers API (requires authentication)
+     * Get offers API (low-level access, requires authentication)
+     * For most use cases, use services and discovery 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)

package/dist/rondevu.js

@@ -1,5 +1,8 @@
 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';
 export class Rondevu {
     constructor(options = {}) {
@@ -9,13 +12,17 @@ export class Rondevu {
         this.rtcSessionDescription = options.RTCSessionDescription;
         this.rtcIceCandidate = options.RTCIceCandidate;
         this.auth = new RondevuAuth(this.baseUrl, this.fetchFn);
+        this.usernames = new RondevuUsername(this.baseUrl);
         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 (requires authentication)
+     * Get offers API (low-level access, requires authentication)
+     * For most use cases, use services and discovery APIs instead
      */
     get offers() {
         if (!this._offers) {
@@ -23,14 +30,34 @@ 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 offers API instance
+        // Create API instances
         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;
     }
     /**

package/dist/service-pool.d.ts

@@ -0,0 +1,115 @@
+import RondevuPeer from './peer/index.js';
+import { ServiceHandle } from './services.js';
+/**
+ * Status information about the pool
+ */
+export interface PoolStatus {
+    /** Number of active offers in the pool */
+    activeOffers: number;
+    /** Number of currently connected peers */
+    activeConnections: number;
+    /** Total number of connections handled since start */
+    totalConnectionsHandled: number;
+    /** Number of failed offer creation attempts */
+    failedOfferCreations: number;
+}
+/**
+ * Configuration options for a pooled service
+ */
+export interface ServicePoolOptions {
+    /** Username that owns the service */
+    username: string;
+    /** Private key for signing service operations */
+    privateKey: string;
+    /** Fully qualified service name (e.g., com.example.chat@1.0.0) */
+    serviceFqn: string;
+    /** WebRTC configuration */
+    rtcConfig?: RTCConfiguration;
+    /** Whether the service is publicly discoverable */
+    isPublic?: boolean;
+    /** Optional metadata for the service */
+    metadata?: Record<string, any>;
+    /** Time-to-live for offers in milliseconds */
+    ttl?: number;
+    /** Handler invoked for each new connection */
+    handler: (channel: RTCDataChannel, peer: RondevuPeer, connectionId: string) => void;
+    /** Number of simultaneous open offers to maintain (default: 1) */
+    poolSize?: number;
+    /** Polling interval in milliseconds (default: 2000ms) */
+    pollingInterval?: number;
+    /** Callback for pool status updates */
+    onPoolStatus?: (status: PoolStatus) => void;
+    /** Error handler for pool operations */
+    onError?: (error: Error, context: string) => void;
+}
+/**
+ * Extended service handle with pool-specific methods
+ */
+export interface PooledServiceHandle extends ServiceHandle {
+    /** Get current pool status */
+    getStatus: () => PoolStatus;
+    /** Manually add offers to the pool */
+    addOffers: (count: number) => Promise<void>;
+}
+/**
+ * Manages a pooled service with multiple concurrent connections
+ *
+ * ServicePool coordinates offer creation, answer polling, and connection
+ * management for services that need to handle multiple simultaneous connections.
+ */
+export declare class ServicePool {
+    private baseUrl;
+    private credentials;
+    private options;
+    private offerPool?;
+    private connections;
+    private status;
+    private serviceId?;
+    private uuid?;
+    private offersApi;
+    private usernameApi;
+    constructor(baseUrl: string, credentials: {
+        peerId: string;
+        secret: string;
+    }, options: ServicePoolOptions);
+    /**
+     * Start the pooled service
+     */
+    start(): Promise<PooledServiceHandle>;
+    /**
+     * Stop the pooled service and clean up
+     */
+    stop(): Promise<void>;
+    /**
+     * Handle an answered offer by setting up the connection
+     */
+    private handleConnection;
+    /**
+     * Create multiple offers
+     */
+    private createOffers;
+    /**
+     * Publish the initial service (creates first offer)
+     */
+    private publishInitialService;
+    /**
+     * Manually add offers to the pool
+     */
+    private manualRefill;
+    /**
+     * Get current pool status
+     */
+    private getStatus;
+    /**
+     * Update status and notify listeners
+     */
+    private updateStatus;
+    /**
+     * Handle errors
+     */
+    private handleError;
+    /**
+     * Generate a unique connection ID
+     */
+    private generateConnectionId;
+}