@xtr-dev/rondevu-client 0.9.2 → 0.10.1

package/dist/event-bus.js

@@ -0,0 +1,84 @@
+/**
+ * Type-safe EventBus with event name to payload type mapping
+ */
+/**
+ * EventBus - Type-safe event emitter with inferred event data types
+ *
+ * @example
+ * interface MyEvents {
+ *   'user:connected': { userId: string; timestamp: number };
+ *   'user:disconnected': { userId: string };
+ *   'message:received': string;
+ * }
+ *
+ * const bus = new EventBus<MyEvents>();
+ *
+ * // TypeScript knows data is { userId: string; timestamp: number }
+ * bus.on('user:connected', (data) => {
+ *   console.log(data.userId, data.timestamp);
+ * });
+ *
+ * // TypeScript knows data is string
+ * bus.on('message:received', (data) => {
+ *   console.log(data.toUpperCase());
+ * });
+ */
+export class EventBus {
+    constructor() {
+        this.handlers = new Map();
+    }
+    /**
+     * Subscribe to an event
+     * Returns a cleanup function to unsubscribe
+     */
+    on(event, handler) {
+        if (!this.handlers.has(event)) {
+            this.handlers.set(event, new Set());
+        }
+        this.handlers.get(event).add(handler);
+        // Return cleanup function
+        return () => this.off(event, handler);
+    }
+    /**
+     * Subscribe to an event once (auto-unsubscribe after first call)
+     */
+    once(event, handler) {
+        const wrappedHandler = (data) => {
+            handler(data);
+            this.off(event, wrappedHandler);
+        };
+        this.on(event, wrappedHandler);
+    }
+    /**
+     * Unsubscribe from an event
+     */
+    off(event, handler) {
+        const eventHandlers = this.handlers.get(event);
+        if (eventHandlers) {
+            eventHandlers.delete(handler);
+            if (eventHandlers.size === 0) {
+                this.handlers.delete(event);
+            }
+        }
+    }
+    /**
+     * Emit an event with data
+     */
+    emit(event, data) {
+        const eventHandlers = this.handlers.get(event);
+        if (eventHandlers) {
+            eventHandlers.forEach(handler => handler(data));
+        }
+    }
+    /**
+     * Remove all handlers for a specific event, or all handlers if no event specified
+     */
+    clear(event) {
+        if (event !== undefined) {
+            this.handlers.delete(event);
+        }
+        else {
+            this.handlers.clear();
+        }
+    }
+}

package/dist/index.d.ts

@@ -1,14 +1,18 @@
 /**
  * @xtr-dev/rondevu-client
- * WebRTC peer signaling and discovery client with durable connections
+ * WebRTC peer signaling client
  */
-export { Rondevu } from './rondevu.js';
-export type { RondevuOptions } from './rondevu.js';
-export { RondevuAuth } from './auth.js';
-export type { Credentials, FetchFunction } from './auth.js';
-export { RondevuUsername } from './usernames.js';
-export type { UsernameClaimResult, UsernameCheckResult } from './usernames.js';
-export { DurableConnection } from './durable/connection.js';
-export { DurableChannel } from './durable/channel.js';
-export { DurableService } from './durable/service.js';
-export type { DurableConnectionState, DurableChannelState, DurableConnectionConfig, DurableChannelConfig, DurableServiceConfig, QueuedMessage, DurableConnectionEvents, DurableChannelEvents, DurableServiceEvents, ConnectionInfo, ServiceInfo } from './durable/types.js';
+export { EventBus } from './event-bus.js';
+export { RondevuAPI } from './api.js';
+export { RondevuService } from './rondevu-service.js';
+export { RondevuSignaler } from './signaler.js';
+export { ServiceHost } from './service-host.js';
+export { ServiceClient } from './service-client.js';
+export { WebRTCRondevuConnection } from './connection.js';
+export { createBin } from './bin.js';
+export type { ConnectionInterface, QueueMessageOptions, Message, ConnectionEvents, Signaler, } from './types.js';
+export type { Credentials, Keypair, OfferRequest, Offer, ServiceRequest, Service, IceCandidate, } from './api.js';
+export type { Binnable } from './bin.js';
+export type { RondevuServiceOptions, PublishServiceOptions } from './rondevu-service.js';
+export type { ServiceHostOptions, ServiceHostEvents } from './service-host.js';
+export type { ServiceClientOptions, ServiceClientEvents } from './service-client.js';

package/dist/index.js

@@ -1,14 +1,12 @@
 /**
  * @xtr-dev/rondevu-client
- * WebRTC peer signaling and discovery client with durable connections
+ * WebRTC peer signaling client
  */
-// Export main client class
-export { Rondevu } from './rondevu.js';
-// Export authentication
-export { RondevuAuth } from './auth.js';
-// Export username API
-export { RondevuUsername } from './usernames.js';
-// Export durable connection APIs
-export { DurableConnection } from './durable/connection.js';
-export { DurableChannel } from './durable/channel.js';
-export { DurableService } from './durable/service.js';
+export { EventBus } from './event-bus.js';
+export { RondevuAPI } from './api.js';
+export { RondevuService } from './rondevu-service.js';
+export { RondevuSignaler } from './signaler.js';
+export { ServiceHost } from './service-host.js';
+export { ServiceClient } from './service-client.js';
+export { WebRTCRondevuConnection } from './connection.js';
+export { createBin } from './bin.js';

package/dist/noop-signaler.d.ts

@@ -0,0 +1,14 @@
+import { Signaler } from './types.js';
+import { Binnable } from './bin.js';
+/**
+ * NoOpSignaler - A signaler that does nothing
+ * Used as a placeholder during connection setup before the real signaler is available
+ */
+export declare class NoOpSignaler implements Signaler {
+    addIceCandidate(_candidate: RTCIceCandidate): void;
+    addListener(_callback: (candidate: RTCIceCandidate) => void): Binnable;
+    addOfferListener(_callback: (offer: RTCSessionDescriptionInit) => void): Binnable;
+    addAnswerListener(_callback: (answer: RTCSessionDescriptionInit) => void): Binnable;
+    setOffer(_offer: RTCSessionDescriptionInit): Promise<void>;
+    setAnswer(_answer: RTCSessionDescriptionInit): Promise<void>;
+}

package/dist/noop-signaler.js

@@ -0,0 +1,27 @@
+/**
+ * NoOpSignaler - A signaler that does nothing
+ * Used as a placeholder during connection setup before the real signaler is available
+ */
+export class NoOpSignaler {
+    addIceCandidate(_candidate) {
+        // No-op
+    }
+    addListener(_callback) {
+        // Return no-op cleanup function
+        return () => { };
+    }
+    addOfferListener(_callback) {
+        // Return no-op cleanup function
+        return () => { };
+    }
+    addAnswerListener(_callback) {
+        // Return no-op cleanup function
+        return () => { };
+    }
+    async setOffer(_offer) {
+        // No-op
+    }
+    async setAnswer(_answer) {
+        // No-op
+    }
+}

package/dist/rondevu-service.d.ts

@@ -0,0 +1,81 @@
+import { RondevuAPI, Credentials, Keypair, Service } from './api.js';
+export interface RondevuServiceOptions {
+    apiUrl: string;
+    username: string;
+    keypair?: Keypair;
+    credentials?: Credentials;
+}
+export interface PublishServiceOptions {
+    serviceFqn: string;
+    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',
+ *   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 public key
+     */
+    getPublicKey(): string | null;
+    /**
+     * Check if username has been claimed
+     */
+    isUsernameClaimed(): boolean;
+    /**
+     * Access to underlying API for advanced operations
+     */
+    getAPI(): RondevuAPI;
+}

package/dist/rondevu-service.js

@@ -0,0 +1,131 @@
+import { RondevuAPI } from './api.js';
+/**
+ * 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',
+ *   sdp: offerSdp,
+ *   ttl: 300000,
+ *   isPublic: true,
+ * })
+ * ```
+ */
+export class RondevuService {
+    constructor(options) {
+        this.keypair = null;
+        this.usernameClaimed = false;
+        this.username = options.username;
+        this.keypair = options.keypair || null;
+        this.api = new RondevuAPI(options.apiUrl, options.credentials);
+    }
+    /**
+     * Initialize the service - generates keypair if not provided
+     * Call this before using other methods
+     */
+    async initialize() {
+        if (!this.keypair) {
+            this.keypair = await RondevuAPI.generateKeypair();
+        }
+        // Register with API if no credentials provided
+        if (!this.api['credentials']) {
+            const credentials = await this.api.register();
+            this.api.credentials = credentials;
+        }
+    }
+    /**
+     * Claim the username with Ed25519 signature
+     * Should be called once before publishing services
+     */
+    async claimUsername() {
+        if (!this.keypair) {
+            throw new Error('Service not initialized. Call initialize() first.');
+        }
+        // Check if username is already claimed
+        const check = await this.api.checkUsername(this.username);
+        if (!check.available) {
+            // Verify it's claimed by us
+            if (check.owner === this.keypair.publicKey) {
+                this.usernameClaimed = true;
+                return;
+            }
+            throw new Error(`Username "${this.username}" is already claimed by another user`);
+        }
+        // Generate signature for username claim
+        const message = `claim-username-${this.username}-${Date.now()}`;
+        const signature = await RondevuAPI.signMessage(message, this.keypair.privateKey);
+        // Claim the username
+        await this.api.claimUsername(this.username, this.keypair.publicKey, signature, message);
+        this.usernameClaimed = true;
+    }
+    /**
+     * Publish a service with automatic signature generation
+     */
+    async publishService(options) {
+        if (!this.keypair) {
+            throw new Error('Service not initialized. Call initialize() first.');
+        }
+        if (!this.usernameClaimed) {
+            throw new Error('Username not claimed. Call claimUsername() first or the server will reject the service.');
+        }
+        const { serviceFqn, sdp, ttl, isPublic, metadata } = options;
+        // Generate signature for service publication
+        const message = `publish-${this.username}-${serviceFqn}-${Date.now()}`;
+        const signature = await RondevuAPI.signMessage(message, this.keypair.privateKey);
+        // Create service request
+        const serviceRequest = {
+            username: this.username,
+            serviceFqn,
+            sdp,
+            signature,
+            message,
+            ttl,
+            isPublic,
+            metadata,
+        };
+        // Publish to server
+        return await this.api.publishService(serviceRequest);
+    }
+    /**
+     * Get the current keypair (for backup/storage)
+     */
+    getKeypair() {
+        return this.keypair;
+    }
+    /**
+     * Get the public key
+     */
+    getPublicKey() {
+        return this.keypair?.publicKey || null;
+    }
+    /**
+     * Check if username has been claimed
+     */
+    isUsernameClaimed() {
+        return this.usernameClaimed;
+    }
+    /**
+     * Access to underlying API for advanced operations
+     */
+    getAPI() {
+        return this.api;
+    }
+}

package/dist/service-client.d.ts

@@ -0,0 +1,94 @@
+import { WebRTCRondevuConnection } from './connection.js';
+import { RondevuService } from './rondevu-service.js';
+import { EventBus } from './event-bus.js';
+import { ConnectionInterface } from './types.js';
+export interface ServiceClientOptions {
+    username: string;
+    serviceFqn: string;
+    rondevuService: RondevuService;
+    autoReconnect?: boolean;
+    reconnectDelay?: number;
+    maxReconnectAttempts?: number;
+    rtcConfiguration?: RTCConfiguration;
+}
+export interface ServiceClientEvents {
+    connected: ConnectionInterface;
+    disconnected: {
+        reason: string;
+    };
+    reconnecting: {
+        attempt: number;
+        maxAttempts: number;
+    };
+    error: Error;
+}
+/**
+ * ServiceClient - Connects to a hosted service
+ *
+ * Searches for available service offers and establishes a WebRTC connection.
+ * Optionally supports automatic reconnection on failure.
+ *
+ * @example
+ * ```typescript
+ * const rondevuService = new RondevuService({
+ *   apiUrl: 'https://signal.example.com',
+ *   username: 'client-user',
+ * })
+ *
+ * await rondevuService.initialize()
+ *
+ * const client = new ServiceClient({
+ *   username: 'host-user',
+ *   serviceFqn: 'chat.app@1.0.0',
+ *   rondevuService,
+ *   autoReconnect: true,
+ * })
+ *
+ * await client.connect()
+ *
+ * client.events.on('connected', (conn) => {
+ *   console.log('Connected to service')
+ *   conn.sendMessage('Hello!')
+ * })
+ * ```
+ */
+export declare class ServiceClient {
+    private readonly username;
+    private readonly serviceFqn;
+    private readonly rondevuService;
+    private readonly autoReconnect;
+    private readonly reconnectDelay;
+    private readonly maxReconnectAttempts;
+    private readonly rtcConfiguration?;
+    private connection;
+    private reconnectAttempts;
+    private reconnectTimeout;
+    private readonly bin;
+    private isConnecting;
+    readonly events: EventBus<ServiceClientEvents>;
+    constructor(options: ServiceClientOptions);
+    /**
+     * Connect to the service
+     */
+    connect(): Promise<WebRTCRondevuConnection>;
+    /**
+     * Disconnect from the service
+     */
+    disconnect(): void;
+    /**
+     * Get the current connection
+     */
+    getConnection(): WebRTCRondevuConnection | null;
+    /**
+     * Check if currently connected
+     */
+    isConnected(): boolean;
+    /**
+     * Handle connection state changes
+     */
+    private handleConnectionStateChange;
+    /**
+     * Schedule a reconnection attempt
+     */
+    private scheduleReconnect;
+}

package/dist/service-client.js

@@ -0,0 +1,186 @@
+import { WebRTCRondevuConnection } from './connection.js';
+import { WebRTCContext } from './webrtc-context.js';
+import { RondevuSignaler } from './signaler.js';
+import { EventBus } from './event-bus.js';
+import { createBin } from './bin.js';
+/**
+ * ServiceClient - Connects to a hosted service
+ *
+ * Searches for available service offers and establishes a WebRTC connection.
+ * Optionally supports automatic reconnection on failure.
+ *
+ * @example
+ * ```typescript
+ * const rondevuService = new RondevuService({
+ *   apiUrl: 'https://signal.example.com',
+ *   username: 'client-user',
+ * })
+ *
+ * await rondevuService.initialize()
+ *
+ * const client = new ServiceClient({
+ *   username: 'host-user',
+ *   serviceFqn: 'chat.app@1.0.0',
+ *   rondevuService,
+ *   autoReconnect: true,
+ * })
+ *
+ * await client.connect()
+ *
+ * client.events.on('connected', (conn) => {
+ *   console.log('Connected to service')
+ *   conn.sendMessage('Hello!')
+ * })
+ * ```
+ */
+export class ServiceClient {
+    constructor(options) {
+        this.connection = null;
+        this.reconnectAttempts = 0;
+        this.reconnectTimeout = null;
+        this.bin = createBin();
+        this.isConnecting = false;
+        this.events = new EventBus();
+        this.username = options.username;
+        this.serviceFqn = options.serviceFqn;
+        this.rondevuService = options.rondevuService;
+        this.autoReconnect = options.autoReconnect !== false;
+        this.reconnectDelay = options.reconnectDelay || 2000;
+        this.maxReconnectAttempts = options.maxReconnectAttempts || 5;
+        this.rtcConfiguration = options.rtcConfiguration;
+    }
+    /**
+     * Connect to the service
+     */
+    async connect() {
+        if (this.isConnecting) {
+            throw new Error('Already connecting');
+        }
+        if (this.connection && this.connection.state === 'connected') {
+            return this.connection;
+        }
+        this.isConnecting = true;
+        try {
+            // Search for available services
+            const services = await this.rondevuService
+                .getAPI()
+                .searchServices(this.username, this.serviceFqn);
+            if (services.length === 0) {
+                throw new Error(`No services found for ${this.username}/${this.serviceFqn}`);
+            }
+            // Get the first available service
+            const service = services[0];
+            // Get service details including SDP
+            const serviceDetails = await this.rondevuService.getAPI().getService(service.uuid);
+            // Create WebRTC context with signaler for this offer
+            const signaler = new RondevuSignaler(this.rondevuService.getAPI(), serviceDetails.offerId);
+            const context = new WebRTCContext(signaler, this.rtcConfiguration);
+            // Create connection (answerer role)
+            const conn = new WebRTCRondevuConnection({
+                id: `client-${this.serviceFqn}-${Date.now()}`,
+                service: this.serviceFqn,
+                offer: {
+                    type: 'offer',
+                    sdp: serviceDetails.sdp,
+                },
+                context,
+            });
+            // Wait for answer to be created
+            await conn.ready;
+            // Get answer SDP
+            if (!conn.connection?.localDescription?.sdp) {
+                throw new Error('Failed to create answer SDP');
+            }
+            const answerSdp = conn.connection.localDescription.sdp;
+            // Send answer to server
+            await this.rondevuService.getAPI().answerOffer(serviceDetails.offerId, answerSdp);
+            // Track connection
+            this.connection = conn;
+            this.reconnectAttempts = 0;
+            // Listen for state changes
+            const cleanup = conn.events.on('state-change', state => {
+                this.handleConnectionStateChange(state);
+            });
+            this.bin(cleanup);
+            this.isConnecting = false;
+            // Emit connected event when actually connected
+            if (conn.state === 'connected') {
+                this.events.emit('connected', conn);
+            }
+            return conn;
+        }
+        catch (error) {
+            this.isConnecting = false;
+            this.events.emit('error', error);
+            throw error;
+        }
+    }
+    /**
+     * Disconnect from the service
+     */
+    disconnect() {
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+        }
+        if (this.connection) {
+            this.connection.disconnect();
+            this.connection = null;
+        }
+        this.bin.clean();
+        this.reconnectAttempts = 0;
+    }
+    /**
+     * Get the current connection
+     */
+    getConnection() {
+        return this.connection;
+    }
+    /**
+     * Check if currently connected
+     */
+    isConnected() {
+        return this.connection?.state === 'connected';
+    }
+    /**
+     * Handle connection state changes
+     */
+    handleConnectionStateChange(state) {
+        if (state === 'connected') {
+            this.events.emit('connected', this.connection);
+            this.reconnectAttempts = 0;
+        }
+        else if (state === 'disconnected') {
+            this.events.emit('disconnected', { reason: 'Connection closed' });
+            // Attempt reconnection if enabled
+            if (this.autoReconnect && this.reconnectAttempts < this.maxReconnectAttempts) {
+                this.scheduleReconnect();
+            }
+        }
+    }
+    /**
+     * Schedule a reconnection attempt
+     */
+    scheduleReconnect() {
+        if (this.reconnectTimeout) {
+            return;
+        }
+        this.reconnectAttempts++;
+        this.events.emit('reconnecting', {
+            attempt: this.reconnectAttempts,
+            maxAttempts: this.maxReconnectAttempts,
+        });
+        // Exponential backoff
+        const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+        this.reconnectTimeout = setTimeout(() => {
+            this.reconnectTimeout = null;
+            this.connect().catch(error => {
+                this.events.emit('error', error);
+                // Schedule next attempt if we haven't exceeded max attempts
+                if (this.reconnectAttempts < this.maxReconnectAttempts) {
+                    this.scheduleReconnect();
+                }
+            });
+        }, delay);
+    }
+}