@xtr-dev/rondevu-client 0.12.4 → 0.13.0

package/dist/{rondevu-service.js → rondevu.js}

@@ -1,60 +1,70 @@
 import { RondevuAPI } from './api.js';
 /**
- * RondevuService - High-level service management with automatic signature handling
+ * Rondevu - Complete WebRTC signaling client
  *
- * Provides a simplified API for:
+ * Provides a unified API for:
  * - Username claiming with Ed25519 signatures
  * - Service publishing with automatic signature generation
+ * - Service discovery (direct, random, paginated)
+ * - WebRTC signaling (offer/answer exchange, ICE relay)
  * - Keypair management
  *
  * @example
  * ```typescript
- * // Initialize service (generates keypair automatically)
- * const service = new RondevuService({
+ * // Initialize (generates keypair automatically)
+ * const rondevu = new Rondevu({
  *   apiUrl: 'https://signal.example.com',
- *   username: 'myusername',
+ *   username: 'alice',
  * })
  *
- * await service.initialize()
+ * await rondevu.initialize()
  *
  * // Claim username (one time)
- * await service.claimUsername()
+ * await rondevu.claimUsername()
  *
  * // Publish a service
- * const publishedService = await service.publishService({
- *   serviceFqn: 'chat.app@1.0.0',
+ * const publishedService = await rondevu.publishService({
+ *   serviceFqn: 'chat:1.0.0@alice',
  *   offers: [{ sdp: offerSdp }],
  *   ttl: 300000,
- *   isPublic: true,
  * })
+ *
+ * // Discover a service
+ * const service = await rondevu.getService('chat:1.0.0@bob')
+ *
+ * // Post answer
+ * await rondevu.postOfferAnswer(service.serviceFqn, service.offerId, answerSdp)
  * ```
  */
-export class RondevuService {
+export class Rondevu {
     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);
-        console.log('[RondevuService] Constructor called:', {
+        console.log('[Rondevu] Constructor called:', {
             username: this.username,
             hasKeypair: !!this.keypair,
             publicKey: this.keypair?.publicKey
         });
     }
+    // ============================================
+    // Initialization
+    // ============================================
     /**
      * Initialize the service - generates keypair if not provided
      * Call this before using other methods
      */
     async initialize() {
-        console.log('[RondevuService] Initialize called, hasKeypair:', !!this.keypair);
+        console.log('[Rondevu] Initialize called, hasKeypair:', !!this.keypair);
         if (!this.keypair) {
-            console.log('[RondevuService] Generating new keypair...');
+            console.log('[Rondevu] Generating new keypair...');
             this.keypair = await RondevuAPI.generateKeypair();
-            console.log('[RondevuService] Generated keypair, publicKey:', this.keypair.publicKey);
+            console.log('[Rondevu] Generated keypair, publicKey:', this.keypair.publicKey);
         }
         else {
-            console.log('[RondevuService] Using existing keypair, publicKey:', this.keypair.publicKey);
+            console.log('[Rondevu] Using existing keypair, publicKey:', this.keypair.publicKey);
         }
         // Register with API if no credentials provided
         if (!this.api['credentials']) {
@@ -62,13 +72,16 @@ export class RondevuService {
             this.api.setCredentials(credentials);
         }
     }
+    // ============================================
+    // Username Management
+    // ============================================
     /**
      * 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.');
+            throw new Error('Not initialized. Call initialize() first.');
         }
         // Check if username is already claimed
         const check = await this.api.checkUsername(this.username);
@@ -87,34 +100,116 @@ export class RondevuService {
         await this.api.claimUsername(this.username, this.keypair.publicKey, signature, message);
         this.usernameClaimed = true;
     }
+    /**
+     * Check if username has been claimed (checks with server)
+     */
+    async isUsernameClaimed() {
+        if (!this.keypair) {
+            return false;
+        }
+        try {
+            const check = await this.api.checkUsername(this.username);
+            // Debug logging
+            console.log('[Rondevu] Username check:', {
+                username: this.username,
+                available: check.available,
+                serverPublicKey: check.publicKey,
+                localPublicKey: this.keypair.publicKey,
+                match: check.publicKey === this.keypair.publicKey
+            });
+            // Username is claimed if it's not available and owned by our public key
+            const claimed = !check.available && check.publicKey === this.keypair.publicKey;
+            // Update internal flag to match server state
+            this.usernameClaimed = claimed;
+            return claimed;
+        }
+        catch (err) {
+            console.error('Failed to check username claim status:', err);
+            return false;
+        }
+    }
+    // ============================================
+    // Service Publishing
+    // ============================================
     /**
      * Publish a service with automatic signature generation
      */
     async publishService(options) {
         if (!this.keypair) {
-            throw new Error('Service not initialized. Call initialize() first.');
+            throw new Error('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, offers, ttl, isPublic, metadata } = options;
+        const { serviceFqn, offers, ttl } = 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,
+            serviceFqn, // Must include @username
             offers,
             signature,
             message,
             ttl,
-            isPublic,
-            metadata,
         };
         // Publish to server
         return await this.api.publishService(serviceRequest);
     }
+    // ============================================
+    // Service Discovery
+    // ============================================
+    /**
+     * Get service by FQN (with username) - Direct lookup
+     * Example: chat:1.0.0@alice
+     */
+    async getService(serviceFqn) {
+        return await this.api.getService(serviceFqn);
+    }
+    /**
+     * Discover a random available service without knowing the username
+     * Example: chat:1.0.0 (without @username)
+     */
+    async discoverService(serviceVersion) {
+        return await this.api.discoverService(serviceVersion);
+    }
+    /**
+     * Discover multiple available services with pagination
+     * Example: chat:1.0.0 (without @username)
+     */
+    async discoverServices(serviceVersion, limit = 10, offset = 0) {
+        return await this.api.discoverServices(serviceVersion, limit, offset);
+    }
+    // ============================================
+    // WebRTC Signaling
+    // ============================================
+    /**
+     * Post answer SDP to specific offer
+     */
+    async postOfferAnswer(serviceFqn, offerId, sdp) {
+        return await this.api.postOfferAnswer(serviceFqn, offerId, sdp);
+    }
+    /**
+     * Get answer SDP (offerer polls this)
+     */
+    async getOfferAnswer(serviceFqn, offerId) {
+        return await this.api.getOfferAnswer(serviceFqn, offerId);
+    }
+    /**
+     * Add ICE candidates to specific offer
+     */
+    async addOfferIceCandidates(serviceFqn, offerId, candidates) {
+        return await this.api.addOfferIceCandidates(serviceFqn, offerId, candidates);
+    }
+    /**
+     * Get ICE candidates for specific offer (with polling support)
+     */
+    async getOfferIceCandidates(serviceFqn, offerId, since = 0) {
+        return await this.api.getOfferIceCandidates(serviceFqn, offerId, since);
+    }
+    // ============================================
+    // Utility Methods
+    // ============================================
     /**
      * Get the current keypair (for backup/storage)
      */
@@ -133,36 +228,9 @@ export class RondevuService {
     getPublicKey() {
         return this.keypair?.publicKey || null;
     }
-    /**
-     * Check if username has been claimed (checks with server)
-     */
-    async isUsernameClaimed() {
-        if (!this.keypair) {
-            return false;
-        }
-        try {
-            const check = await this.api.checkUsername(this.username);
-            // Debug logging
-            console.log('[RondevuService] Username check:', {
-                username: this.username,
-                available: check.available,
-                serverPublicKey: check.publicKey,
-                localPublicKey: this.keypair.publicKey,
-                match: check.publicKey === this.keypair.publicKey
-            });
-            // Username is claimed if it's not available and owned by our public key
-            const claimed = !check.available && check.publicKey === this.keypair.publicKey;
-            // Update internal flag to match server state
-            this.usernameClaimed = claimed;
-            return claimed;
-        }
-        catch (err) {
-            console.error('Failed to check username claim status:', err);
-            return false;
-        }
-    }
     /**
      * Access to underlying API for advanced operations
+     * @deprecated Use direct methods on Rondevu instance instead
      */
     getAPI() {
         return this.api;

package/dist/types.d.ts

@@ -1,26 +1,13 @@
 /**
- * Core connection types
+ * Core signaling types
+ */
+/**
+ * Cleanup function returned by listener methods
+ */
+export type Binnable = () => void;
+/**
+ * Signaler interface for WebRTC offer/answer/ICE exchange
  */
-import { EventBus } from './event-bus.js';
-import { Binnable } from './bin.js';
-export type Message = string | ArrayBuffer;
-export interface QueueMessageOptions {
-    expiresAt?: number;
-}
-export interface ConnectionEvents {
-    'state-change': ConnectionInterface['state'];
-    message: Message;
-}
-export declare const ConnectionStates: readonly ["connected", "disconnected", "connecting"];
-export declare const isConnectionState: (state: string) => state is (typeof ConnectionStates)[number];
-export interface ConnectionInterface {
-    state: (typeof ConnectionStates)[number];
-    lastActive: number;
-    expiresAt?: number;
-    events: EventBus<ConnectionEvents>;
-    queueMessage(message: Message, options?: QueueMessageOptions): Promise<void>;
-    sendMessage(message: Message): Promise<boolean>;
-}
 export interface Signaler {
     addIceCandidate(candidate: RTCIceCandidate): Promise<void>;
     addListener(callback: (candidate: RTCIceCandidate) => void): Binnable;

package/dist/types.js

@@ -1,6 +1,4 @@
-export const ConnectionStates = [
-    'connected',
-    'disconnected',
-    'connecting'
-];
-export const isConnectionState = (state) => ConnectionStates.includes(state);
+/**
+ * Core signaling types
+ */
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xtr-dev/rondevu-client",
-  "version": "0.12.4",
+  "version": "0.13.0",
   "description": "TypeScript client for Rondevu with durable WebRTC connections, automatic reconnection, and message queuing",
   "type": "module",
   "main": "dist/index.js",

package/dist/bin.d.ts

@@ -1,35 +0,0 @@
-/**
- * Binnable - A cleanup function that can be synchronous or asynchronous
- *
- * Used to unsubscribe from events, close connections, or perform other cleanup operations.
- */
-export type Binnable = () => void | Promise<void>;
-/**
- * Create a cleanup function collector (garbage bin)
- *
- * Collects cleanup functions and provides a single `clean()` method to execute all of them.
- * Useful for managing multiple cleanup operations in a single place.
- *
- * @returns A function that accepts cleanup functions and has a `clean()` method
- *
- * @example
- * ```typescript
- * const bin = createBin();
- *
- * // Add cleanup functions
- * bin(
- *   () => console.log('Cleanup 1'),
- *   () => connection.close(),
- *   () => clearInterval(timer)
- * );
- *
- * // Later, clean everything
- * bin.clean(); // Executes all cleanup functions
- * ```
- */
-export declare const createBin: () => ((...rubbish: Binnable[]) => number) & {
-    /**
-     * Execute all cleanup functions and clear the bin
-     */
-    clean: () => void;
-};

package/dist/bin.js

@@ -1,35 +0,0 @@
-/**
- * Create a cleanup function collector (garbage bin)
- *
- * Collects cleanup functions and provides a single `clean()` method to execute all of them.
- * Useful for managing multiple cleanup operations in a single place.
- *
- * @returns A function that accepts cleanup functions and has a `clean()` method
- *
- * @example
- * ```typescript
- * const bin = createBin();
- *
- * // Add cleanup functions
- * bin(
- *   () => console.log('Cleanup 1'),
- *   () => connection.close(),
- *   () => clearInterval(timer)
- * );
- *
- * // Later, clean everything
- * bin.clean(); // Executes all cleanup functions
- * ```
- */
-export const createBin = () => {
-    const bin = [];
-    return Object.assign((...rubbish) => bin.push(...rubbish), {
-        /**
-         * Execute all cleanup functions and clear the bin
-         */
-        clean: () => {
-            bin.forEach(binnable => binnable());
-            bin.length = 0;
-        },
-    });
-};

package/dist/connection-manager.d.ts

@@ -1,104 +0,0 @@
-import { WebRTCRondevuConnection } from './connection.js';
-import { Credentials } from './api.js';
-import { ConnectionInterface } from './types.js';
-export interface ConnectionManagerOptions {
-    apiUrl: string;
-    username: string;
-    credentials?: Credentials;
-    autoReconnect?: boolean;
-    reconnectDelay?: number;
-    maxReconnectAttempts?: number;
-}
-export interface HostServiceOptions {
-    service: string;
-    ttl?: number;
-    onConnection?: (connection: ConnectionInterface) => void;
-}
-export interface ConnectToServiceOptions {
-    username: string;
-    service: string;
-    onConnection?: (connection: ConnectionInterface) => void;
-}
-/**
- * ConnectionManager - High-level connection management
- *
- * @example
- * // Host a service
- * const manager = new ConnectionManager({
- *   apiUrl: 'https://api.ronde.vu',
- *   credentials: await api.register()
- * })
- *
- * await manager.hostService({
- *   service: 'chat.app@1.0.0',
- *   onConnection: (conn) => {
- *     conn.events.on('message', msg => console.log('Received:', msg))
- *   }
- * })
- *
- * @example
- * // Connect to a service
- * const connection = await manager.connectToService({
- *   username: 'alice',
- *   service: 'chat.app@1.0.0'
- * })
- *
- * await connection.sendMessage('Hello!')
- */
-export declare class ConnectionManager {
-    private readonly api;
-    private readonly username;
-    private readonly connections;
-    private readonly autoReconnect;
-    private readonly reconnectDelay;
-    private readonly maxReconnectAttempts;
-    private readonly bin;
-    constructor(options: ConnectionManagerOptions);
-    /**
-     * Host a service - Creates an offer and publishes it to the signaling server
-     *
-     * The service will automatically accept incoming connections and manage them.
-     * Each new connection triggers the onConnection callback.
-     *
-     * @param options - Service hosting options
-     * @returns Promise that resolves when the service is published
-     */
-    hostService(options: HostServiceOptions): Promise<void>;
-    /**
-     * Connect to a hosted service
-     *
-     * Searches for the service, retrieves the offer, and creates an answering connection.
-     *
-     * @param options - Connection options
-     * @returns The established connection
-     */
-    connectToService(options: ConnectToServiceOptions): Promise<WebRTCRondevuConnection>;
-    /**
-     * Get a connection by ID
-     */
-    getConnection(id: string): WebRTCRondevuConnection | undefined;
-    /**
-     * Get all managed connections
-     */
-    getAllConnections(): WebRTCRondevuConnection[];
-    /**
-     * Remove a connection
-     */
-    private removeConnection;
-    /**
-     * Schedule reconnection for a failed connection
-     */
-    private scheduleReconnect;
-    /**
-     * Attempt to reconnect a failed connection
-     */
-    private attemptReconnect;
-    /**
-     * Create a temporary signaler (used during initial offer creation)
-     */
-    private createTempSignaler;
-    /**
-     * Clean up all connections and resources
-     */
-    destroy(): void;
-}