@xtr-dev/rondevu-client 0.12.4 → 0.13.0

package/dist/rondevu-service.d.ts

@@ -1,87 +0,0 @@
-import { RondevuAPI, Credentials, Keypair, Service } from './api.js';
-export interface RondevuServiceOptions {
-    apiUrl: string;
-    username: string;
-    keypair?: Keypair;
-    credentials?: Credentials;
-}
-export interface PublishServiceOptions {
-    serviceFqn: string;
-    offers: Array<{
-        sdp: string;
-    }>;
-    ttl?: number;
-    isPublic?: boolean;
-    metadata?: Record<string, any>;
-}
-/**
- * RondevuService - High-level service management with automatic signature handling
- *
- * Provides a simplified API for:
- * - Username claiming with Ed25519 signatures
- * - Service publishing with automatic signature generation
- * - Keypair management
- *
- * @example
- * ```typescript
- * // Initialize service (generates keypair automatically)
- * const service = new RondevuService({
- *   apiUrl: 'https://signal.example.com',
- *   username: 'myusername',
- * })
- *
- * await service.initialize()
- *
- * // Claim username (one time)
- * await service.claimUsername()
- *
- * // Publish a service
- * const publishedService = await service.publishService({
- *   serviceFqn: 'chat.app@1.0.0',
- *   offers: [{ sdp: offerSdp }],
- *   ttl: 300000,
- *   isPublic: true,
- * })
- * ```
- */
-export declare class RondevuService {
-    private readonly api;
-    private readonly username;
-    private keypair;
-    private usernameClaimed;
-    constructor(options: RondevuServiceOptions);
-    /**
-     * Initialize the service - generates keypair if not provided
-     * Call this before using other methods
-     */
-    initialize(): Promise<void>;
-    /**
-     * Claim the username with Ed25519 signature
-     * Should be called once before publishing services
-     */
-    claimUsername(): Promise<void>;
-    /**
-     * Publish a service with automatic signature generation
-     */
-    publishService(options: PublishServiceOptions): Promise<Service>;
-    /**
-     * Get the current keypair (for backup/storage)
-     */
-    getKeypair(): Keypair | null;
-    /**
-     * Get the username
-     */
-    getUsername(): string;
-    /**
-     * Get the public key
-     */
-    getPublicKey(): string | null;
-    /**
-     * Check if username has been claimed (checks with server)
-     */
-    isUsernameClaimed(): Promise<boolean>;
-    /**
-     * Access to underlying API for advanced operations
-     */
-    getAPI(): RondevuAPI;
-}

package/dist/service-client.d.ts

@@ -1,77 +0,0 @@
-import { RondevuService } from './rondevu-service.js';
-import { RTCDurableConnection } from './durable-connection.js';
-import { EventBus } from './event-bus.js';
-export interface ServiceClientOptions {
-    username: string;
-    serviceFqn: string;
-    rondevuService: RondevuService;
-    autoReconnect?: boolean;
-    maxReconnectAttempts?: number;
-    rtcConfiguration?: RTCConfiguration;
-}
-export interface ServiceClientEvents {
-    connected: RTCDurableConnection;
-    disconnected: void;
-    reconnecting: {
-        attempt: number;
-        maxAttempts: number;
-    };
-    error: Error;
-}
-/**
- * ServiceClient - High-level wrapper for connecting to a WebRTC service
- *
- * Simplifies client connection by handling:
- * - Service discovery
- * - Offer/answer exchange
- * - ICE candidate polling
- * - Automatic reconnection
- *
- * @example
- * ```typescript
- * const client = new ServiceClient({
- *     username: 'host-user',
- *     serviceFqn: 'chat.app@1.0.0',
- *     rondevuService: myService
- * })
- *
- * client.events.on('connected', conn => {
- *     conn.events.on('message', msg => console.log('Received:', msg))
- *     conn.sendMessage('Hello from client!')
- * })
- *
- * await client.connect()
- * ```
- */
-export declare class ServiceClient {
-    private options;
-    events: EventBus<ServiceClientEvents>;
-    private signaler;
-    private webrtcContext;
-    private connection;
-    private autoReconnect;
-    private maxReconnectAttempts;
-    private reconnectAttempts;
-    private isConnecting;
-    constructor(options: ServiceClientOptions);
-    /**
-     * Connect to the service
-     */
-    connect(): Promise<RTCDurableConnection>;
-    /**
-     * Disconnect from the service
-     */
-    dispose(): void;
-    /**
-     * @deprecated Use dispose() instead
-     */
-    disconnect(): void;
-    /**
-     * Attempt to reconnect
-     */
-    private attemptReconnect;
-    /**
-     * Get the current connection
-     */
-    getConnection(): RTCDurableConnection | null;
-}

package/dist/service-client.js

@@ -1,158 +0,0 @@
-import { RondevuSignaler } from './rondevu-signaler.js';
-import { WebRTCContext } from './webrtc-context.js';
-import { RTCDurableConnection } from './durable-connection.js';
-import { EventBus } from './event-bus.js';
-/**
- * ServiceClient - High-level wrapper for connecting to a WebRTC service
- *
- * Simplifies client connection by handling:
- * - Service discovery
- * - Offer/answer exchange
- * - ICE candidate polling
- * - Automatic reconnection
- *
- * @example
- * ```typescript
- * const client = new ServiceClient({
- *     username: 'host-user',
- *     serviceFqn: 'chat.app@1.0.0',
- *     rondevuService: myService
- * })
- *
- * client.events.on('connected', conn => {
- *     conn.events.on('message', msg => console.log('Received:', msg))
- *     conn.sendMessage('Hello from client!')
- * })
- *
- * await client.connect()
- * ```
- */
-export class ServiceClient {
-    constructor(options) {
-        this.options = options;
-        this.signaler = null;
-        this.connection = null;
-        this.reconnectAttempts = 0;
-        this.isConnecting = false;
-        this.events = new EventBus();
-        this.webrtcContext = new WebRTCContext(options.rtcConfiguration);
-        this.autoReconnect = options.autoReconnect !== undefined ? options.autoReconnect : true;
-        this.maxReconnectAttempts = options.maxReconnectAttempts || 5;
-    }
-    /**
-     * Connect to the service
-     */
-    async connect() {
-        if (this.isConnecting) {
-            throw new Error('Connection already in progress');
-        }
-        if (this.connection) {
-            throw new Error('Already connected. Disconnect first.');
-        }
-        this.isConnecting = true;
-        try {
-            // Create signaler
-            this.signaler = new RondevuSignaler(this.options.rondevuService, this.options.serviceFqn, this.options.username);
-            // Wait for remote offer from signaler
-            const remoteOffer = await new Promise((resolve, reject) => {
-                const timeout = setTimeout(() => {
-                    reject(new Error('Service discovery timeout'));
-                }, 30000);
-                this.signaler.addOfferListener((offer) => {
-                    clearTimeout(timeout);
-                    resolve(offer);
-                });
-            });
-            // Create connection with remote offer (makes us the answerer)
-            const connection = new RTCDurableConnection({
-                context: this.webrtcContext,
-                signaler: this.signaler,
-                offer: remoteOffer
-            });
-            // Wait for connection to be ready
-            await connection.ready;
-            // Set up connection event listeners
-            connection.events.on('state-change', (state) => {
-                if (state === 'connected') {
-                    this.reconnectAttempts = 0;
-                    this.events.emit('connected', connection);
-                }
-                else if (state === 'disconnected') {
-                    this.events.emit('disconnected', undefined);
-                    if (this.autoReconnect && this.reconnectAttempts < this.maxReconnectAttempts) {
-                        this.attemptReconnect();
-                    }
-                }
-            });
-            this.connection = connection;
-            this.isConnecting = false;
-            return connection;
-        }
-        catch (err) {
-            this.isConnecting = false;
-            const error = err instanceof Error ? err : new Error(String(err));
-            this.events.emit('error', error);
-            throw error;
-        }
-    }
-    /**
-     * Disconnect from the service
-     */
-    dispose() {
-        if (this.signaler) {
-            this.signaler.dispose();
-            this.signaler = null;
-        }
-        if (this.connection) {
-            this.connection.disconnect();
-            this.connection = null;
-        }
-        this.isConnecting = false;
-        this.reconnectAttempts = 0;
-    }
-    /**
-     * @deprecated Use dispose() instead
-     */
-    disconnect() {
-        this.dispose();
-    }
-    /**
-     * Attempt to reconnect
-     */
-    async attemptReconnect() {
-        this.reconnectAttempts++;
-        this.events.emit('reconnecting', {
-            attempt: this.reconnectAttempts,
-            maxAttempts: this.maxReconnectAttempts
-        });
-        // Cleanup old connection
-        if (this.signaler) {
-            this.signaler.dispose();
-            this.signaler = null;
-        }
-        if (this.connection) {
-            this.connection = null;
-        }
-        // Wait a bit before reconnecting
-        await new Promise(resolve => setTimeout(resolve, 1000 * this.reconnectAttempts));
-        try {
-            await this.connect();
-        }
-        catch (err) {
-            console.error('Reconnection attempt failed:', err);
-            if (this.reconnectAttempts < this.maxReconnectAttempts) {
-                this.attemptReconnect();
-            }
-            else {
-                const error = new Error('Max reconnection attempts reached');
-                this.events.emit('error', error);
-            }
-        }
-    }
-    /**
-     * Get the current connection
-     */
-    getConnection() {
-        return this.connection;
-    }
-}

package/dist/service-host.d.ts

@@ -1,67 +0,0 @@
-import { RondevuService } from './rondevu-service.js';
-import { RTCDurableConnection } from './durable-connection.js';
-import { EventBus } from './event-bus.js';
-export interface ServiceHostOptions {
-    service: string;
-    rondevuService: RondevuService;
-    maxPeers?: number;
-    ttl?: number;
-    isPublic?: boolean;
-    rtcConfiguration?: RTCConfiguration;
-    metadata?: Record<string, any>;
-}
-export interface ServiceHostEvents {
-    connection: RTCDurableConnection;
-    error: Error;
-}
-/**
- * ServiceHost - High-level wrapper for hosting a WebRTC service
- *
- * Simplifies hosting by handling:
- * - Offer/answer exchange
- * - ICE candidate polling
- * - Connection pool management
- * - Automatic reconnection
- *
- * @example
- * ```typescript
- * const host = new ServiceHost({
- *     service: 'chat.app@1.0.0',
- *     rondevuService: myService,
- *     maxPeers: 5
- * })
- *
- * host.events.on('connection', conn => {
- *     conn.events.on('message', msg => console.log('Received:', msg))
- *     conn.sendMessage('Hello!')
- * })
- *
- * await host.start()
- * ```
- */
-export declare class ServiceHost {
-    private options;
-    events: EventBus<ServiceHostEvents>;
-    private signaler;
-    private webrtcContext;
-    private connections;
-    private maxPeers;
-    private running;
-    constructor(options: ServiceHostOptions);
-    /**
-     * Start hosting the service
-     */
-    start(): Promise<void>;
-    /**
-     * Create the next connection for incoming peers
-     */
-    private createNextConnection;
-    /**
-     * Stop hosting the service
-     */
-    dispose(): void;
-    /**
-     * Get all active connections
-     */
-    getConnections(): RTCDurableConnection[];
-}

package/dist/service-host.js

@@ -1,120 +0,0 @@
-import { RondevuSignaler } from './rondevu-signaler.js';
-import { WebRTCContext } from './webrtc-context.js';
-import { RTCDurableConnection } from './durable-connection.js';
-import { EventBus } from './event-bus.js';
-/**
- * ServiceHost - High-level wrapper for hosting a WebRTC service
- *
- * Simplifies hosting by handling:
- * - Offer/answer exchange
- * - ICE candidate polling
- * - Connection pool management
- * - Automatic reconnection
- *
- * @example
- * ```typescript
- * const host = new ServiceHost({
- *     service: 'chat.app@1.0.0',
- *     rondevuService: myService,
- *     maxPeers: 5
- * })
- *
- * host.events.on('connection', conn => {
- *     conn.events.on('message', msg => console.log('Received:', msg))
- *     conn.sendMessage('Hello!')
- * })
- *
- * await host.start()
- * ```
- */
-export class ServiceHost {
-    constructor(options) {
-        this.options = options;
-        this.signaler = null;
-        this.connections = [];
-        this.running = false;
-        this.events = new EventBus();
-        this.webrtcContext = new WebRTCContext(options.rtcConfiguration);
-        this.maxPeers = options.maxPeers || 5;
-    }
-    /**
-     * Start hosting the service
-     */
-    async start() {
-        if (this.running) {
-            throw new Error('ServiceHost already running');
-        }
-        this.running = true;
-        // Create signaler
-        this.signaler = new RondevuSignaler(this.options.rondevuService, this.options.service);
-        // Create first connection (offerer)
-        const connection = new RTCDurableConnection({
-            context: this.webrtcContext,
-            signaler: this.signaler,
-            offer: null // null means we're the offerer
-        });
-        // Wait for connection to be ready
-        await connection.ready;
-        // Set up connection event listeners
-        connection.events.on('state-change', (state) => {
-            if (state === 'connected') {
-                this.connections.push(connection);
-                this.events.emit('connection', connection);
-                // Create next connection if under maxPeers
-                if (this.connections.length < this.maxPeers) {
-                    this.createNextConnection().catch(err => {
-                        console.error('Failed to create next connection:', err);
-                        this.events.emit('error', err);
-                    });
-                }
-            }
-            else if (state === 'disconnected') {
-                // Remove from connections list
-                const index = this.connections.indexOf(connection);
-                if (index > -1) {
-                    this.connections.splice(index, 1);
-                }
-            }
-        });
-        // Publish service with the offer
-        const offer = connection.connection?.localDescription;
-        if (!offer?.sdp) {
-            throw new Error('Offer SDP is empty');
-        }
-        await this.signaler.setOffer(offer);
-    }
-    /**
-     * Create the next connection for incoming peers
-     */
-    async createNextConnection() {
-        if (!this.signaler || !this.running) {
-            return;
-        }
-        // For now, we'll use the same offer for all connections
-        // In a production scenario, you'd create multiple offers
-        // This is a limitation of the current service model
-        // which publishes one offer per service
-    }
-    /**
-     * Stop hosting the service
-     */
-    dispose() {
-        this.running = false;
-        // Cleanup signaler
-        if (this.signaler) {
-            this.signaler.dispose();
-            this.signaler = null;
-        }
-        // Disconnect all connections
-        for (const conn of this.connections) {
-            conn.disconnect();
-        }
-        this.connections = [];
-    }
-    /**
-     * Get all active connections
-     */
-    getConnections() {
-        return [...this.connections];
-    }
-}

package/dist/signaler.d.ts

@@ -1,25 +0,0 @@
-import { Signaler } from './types.js';
-import { Binnable } from './bin.js';
-import { RondevuAPI } from './api.js';
-/**
- * RondevuSignaler - Handles ICE candidate exchange via Rondevu API
- * Uses polling to retrieve remote candidates
- */
-export declare class RondevuSignaler implements Signaler {
-    private api;
-    private offerId;
-    constructor(api: RondevuAPI, offerId: string);
-    addOfferListener(callback: (offer: RTCSessionDescriptionInit) => void): Binnable;
-    addAnswerListener(callback: (answer: RTCSessionDescriptionInit) => void): Binnable;
-    setOffer(offer: RTCSessionDescriptionInit): Promise<void>;
-    setAnswer(answer: RTCSessionDescriptionInit): Promise<void>;
-    /**
-     * Send a local ICE candidate to signaling server
-     */
-    addIceCandidate(candidate: RTCIceCandidate): Promise<void>;
-    /**
-     * Poll for remote ICE candidates and call callback for each one
-     * Returns cleanup function to stop polling
-     */
-    addListener(callback: (candidate: RTCIceCandidate) => void): Binnable;
-}

package/dist/signaler.js

@@ -1,89 +0,0 @@
-/**
- * RondevuSignaler - Handles ICE candidate exchange via Rondevu API
- * Uses polling to retrieve remote candidates
- */
-export class RondevuSignaler {
-    constructor(api, offerId) {
-        this.api = api;
-        this.offerId = offerId;
-    }
-    addOfferListener(callback) {
-        throw new Error('Method not implemented.');
-    }
-    addAnswerListener(callback) {
-        throw new Error('Method not implemented.');
-    }
-    setOffer(offer) {
-        throw new Error('Method not implemented.');
-    }
-    setAnswer(answer) {
-        throw new Error('Method not implemented.');
-    }
-    /**
-     * Send a local ICE candidate to signaling server
-     */
-    async addIceCandidate(candidate) {
-        const candidateData = candidate.toJSON();
-        // Skip empty candidates
-        if (!candidateData.candidate || candidateData.candidate === '') {
-            return;
-        }
-        await this.api.addIceCandidates(this.offerId, [candidateData]);
-    }
-    /**
-     * Poll for remote ICE candidates and call callback for each one
-     * Returns cleanup function to stop polling
-     */
-    addListener(callback) {
-        let lastTimestamp = 0;
-        let polling = true;
-        const poll = async () => {
-            while (polling) {
-                try {
-                    const candidates = await this.api.getIceCandidates(this.offerId, lastTimestamp);
-                    // Process each candidate
-                    for (const item of candidates) {
-                        if (item.candidate &&
-                            item.candidate.candidate &&
-                            item.candidate.candidate !== '') {
-                            try {
-                                const rtcCandidate = new RTCIceCandidate(item.candidate);
-                                callback(rtcCandidate);
-                                lastTimestamp = item.createdAt;
-                            }
-                            catch (err) {
-                                console.warn('Failed to process ICE candidate:', err);
-                                lastTimestamp = item.createdAt;
-                            }
-                        }
-                        else {
-                            lastTimestamp = item.createdAt;
-                        }
-                    }
-                }
-                catch (err) {
-                    // If offer not found or expired, stop polling
-                    if (err instanceof Error &&
-                        (err.message.includes('404') || err.message.includes('410'))) {
-                        console.warn('Offer not found or expired, stopping ICE polling');
-                        polling = false;
-                        break;
-                    }
-                    console.error('Error polling for ICE candidates:', err);
-                }
-                // Poll every second
-                if (polling) {
-                    await new Promise(resolve => setTimeout(resolve, 1000));
-                }
-            }
-        };
-        // Start polling in the background
-        poll().then(() => {
-            console.log('ICE polling started');
-        });
-        // Return cleanup function
-        return () => {
-            polling = false;
-        };
-    }
-}

package/dist/webrtc-context.d.ts

@@ -1,5 +0,0 @@
-export declare class WebRTCContext {
-    private readonly config?;
-    constructor(config?: RTCConfiguration | undefined);
-    createPeerConnection(): RTCPeerConnection;
-}

package/dist/webrtc-context.js

@@ -1,35 +0,0 @@
-const DEFAULT_RTC_CONFIGURATION = {
-    iceServers: [
-        {
-            urls: 'stun:stun.relay.metered.ca:80',
-        },
-        {
-            urls: 'turn:standard.relay.metered.ca:80',
-            username: 'c53a9c971da5e6f3bc959d8d',
-            credential: 'QaccPqtPPaxyokXp',
-        },
-        {
-            urls: 'turn:standard.relay.metered.ca:80?transport=tcp',
-            username: 'c53a9c971da5e6f3bc959d8d',
-            credential: 'QaccPqtPPaxyokXp',
-        },
-        {
-            urls: 'turn:standard.relay.metered.ca:443',
-            username: 'c53a9c971da5e6f3bc959d8d',
-            credential: 'QaccPqtPPaxyokXp',
-        },
-        {
-            urls: 'turns:standard.relay.metered.ca:443?transport=tcp',
-            username: 'c53a9c971da5e6f3bc959d8d',
-            credential: 'QaccPqtPPaxyokXp',
-        },
-    ],
-};
-export class WebRTCContext {
-    constructor(config) {
-        this.config = config;
-    }
-    createPeerConnection() {
-        return new RTCPeerConnection(this.config || DEFAULT_RTC_CONFIGURATION);
-    }
-}