@xtr-dev/rondevu-client 0.10.1 → 0.11.0

package/dist/api.d.ts

@@ -25,20 +25,29 @@ export interface Offer {
     expiresAt: number;
     answererPeerId?: string;
 }
+export interface OfferRequest {
+    sdp: string;
+}
 export interface ServiceRequest {
     username: string;
     serviceFqn: string;
-    sdp: string;
+    offers: OfferRequest[];
     ttl?: number;
     isPublic?: boolean;
     metadata?: Record<string, any>;
     signature: string;
     message: string;
 }
+export interface ServiceOffer {
+    offerId: string;
+    sdp: string;
+    createdAt: number;
+    expiresAt: number;
+}
 export interface Service {
     serviceId: string;
     uuid: string;
-    offerId: string;
+    offers: ServiceOffer[];
     username: string;
     serviceFqn: string;
     isPublic: boolean;
@@ -57,6 +66,10 @@ export declare class RondevuAPI {
     private baseUrl;
     private credentials?;
     constructor(baseUrl: string, credentials?: Credentials | undefined);
+    /**
+     * Set credentials for authentication
+     */
+    setCredentials(credentials: Credentials): void;
     /**
      * Authentication header
      */
@@ -119,15 +132,11 @@ export declare class RondevuAPI {
         sdp: string;
     }>;
     /**
-     * Search services by username
+     * Search services by username - lists all services for a username
      */
     searchServicesByUsername(username: string): Promise<Service[]>;
     /**
-     * Search services by FQN
-     */
-    searchServicesByFqn(serviceFqn: string): Promise<Service[]>;
-    /**
-     * Search services by username AND FQN
+     * Search services by username AND FQN - returns full service details
      */
     searchServices(username: string, serviceFqn: string): Promise<Service[]>;
     /**

package/dist/api.js

@@ -28,6 +28,12 @@ export class RondevuAPI {
         this.baseUrl = baseUrl;
         this.credentials = credentials;
     }
+    /**
+     * Set credentials for authentication
+     */
+    setCredentials(credentials) {
+        this.credentials = credentials;
+    }
     /**
      * Authentication header
      */
@@ -148,14 +154,16 @@ export class RondevuAPI {
         const response = await fetch(`${this.baseUrl}/offers/${offerId}/answer`, {
             headers: this.getAuthHeader(),
         });
-        if (response.status === 404) {
-            return null; // No answer yet
-        }
         if (!response.ok) {
+            // 404 means not yet answered
+            if (response.status === 404) {
+                return null;
+            }
             const error = await response.json().catch(() => ({ error: 'Unknown error' }));
             throw new Error(`Failed to get answer: ${error.error || response.statusText}`);
         }
-        return await response.json();
+        const data = await response.json();
+        return { sdp: data.sdp };
     }
     /**
      * Search offers by topic
@@ -199,7 +207,8 @@ export class RondevuAPI {
             const error = await response.json().catch(() => ({ error: 'Unknown error' }));
             throw new Error(`Failed to get ICE candidates: ${error.error || response.statusText}`);
         }
-        return await response.json();
+        const data = await response.json();
+        return data.candidates || [];
     }
     // ============================================
     // Services
@@ -208,7 +217,7 @@ export class RondevuAPI {
      * Publish a service
      */
     async publishService(service) {
-        const response = await fetch(`${this.baseUrl}/services`, {
+        const response = await fetch(`${this.baseUrl}/users/${encodeURIComponent(service.username)}/services`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
@@ -236,37 +245,31 @@ export class RondevuAPI {
         return await response.json();
     }
     /**
-     * Search services by username
+     * Search services by username - lists all services for a username
      */
     async searchServicesByUsername(username) {
-        const response = await fetch(`${this.baseUrl}/services?username=${encodeURIComponent(username)}`, { headers: this.getAuthHeader() });
+        const response = await fetch(`${this.baseUrl}/users/${encodeURIComponent(username)}/services`, { headers: this.getAuthHeader() });
         if (!response.ok) {
             const error = await response.json().catch(() => ({ error: 'Unknown error' }));
             throw new Error(`Failed to search services: ${error.error || response.statusText}`);
         }
-        return await response.json();
+        const data = await response.json();
+        return data.services || [];
     }
     /**
-     * Search services by FQN
-     */
-    async searchServicesByFqn(serviceFqn) {
-        const response = await fetch(`${this.baseUrl}/services?serviceFqn=${encodeURIComponent(serviceFqn)}`, { headers: this.getAuthHeader() });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to search services: ${error.error || response.statusText}`);
-        }
-        return await response.json();
-    }
-    /**
-     * Search services by username AND FQN
+     * Search services by username AND FQN - returns full service details
      */
     async searchServices(username, serviceFqn) {
-        const response = await fetch(`${this.baseUrl}/services?username=${encodeURIComponent(username)}&serviceFqn=${encodeURIComponent(serviceFqn)}`, { headers: this.getAuthHeader() });
+        const response = await fetch(`${this.baseUrl}/users/${encodeURIComponent(username)}/services/${encodeURIComponent(serviceFqn)}`, { headers: this.getAuthHeader() });
         if (!response.ok) {
+            if (response.status === 404) {
+                return [];
+            }
             const error = await response.json().catch(() => ({ error: 'Unknown error' }));
             throw new Error(`Failed to search services: ${error.error || response.statusText}`);
         }
-        return await response.json();
+        const service = await response.json();
+        return [service];
     }
     // ============================================
     // Usernames
@@ -275,7 +278,7 @@ export class RondevuAPI {
      * Check if username is available
      */
     async checkUsername(username) {
-        const response = await fetch(`${this.baseUrl}/usernames/${encodeURIComponent(username)}/check`);
+        const response = await fetch(`${this.baseUrl}/users/${encodeURIComponent(username)}`);
         if (!response.ok) {
             const error = await response.json().catch(() => ({ error: 'Unknown error' }));
             throw new Error(`Failed to check username: ${error.error || response.statusText}`);
@@ -286,7 +289,7 @@ export class RondevuAPI {
      * Claim a username (requires Ed25519 signature)
      */
     async claimUsername(username, publicKey, signature, message) {
-        const response = await fetch(`${this.baseUrl}/usernames/${encodeURIComponent(username)}`, {
+        const response = await fetch(`${this.baseUrl}/users/${encodeURIComponent(username)}`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',

package/dist/durable-connection.d.ts

@@ -0,0 +1,120 @@
+import { ConnectionEvents, ConnectionInterface, Message, QueueMessageOptions, Signaler } from './types.js';
+import { EventBus } from './event-bus.js';
+import { WebRTCContext } from './webrtc-context';
+export type WebRTCRondevuConnectionOptions = {
+    offer?: RTCSessionDescriptionInit | null;
+    context: WebRTCContext;
+    signaler: Signaler;
+};
+/**
+ * WebRTCRondevuConnection - WebRTC peer connection wrapper with Rondevu signaling
+ *
+ * Manages a WebRTC peer connection lifecycle including:
+ * - Automatic offer/answer creation based on role
+ * - ICE candidate exchange via Rondevu signaling server
+ * - Connection state management with type-safe events
+ * - Data channel creation and message handling
+ *
+ * The connection automatically determines its role (offerer or answerer) based on whether
+ * an offer is provided in the constructor. The offerer creates the data channel, while
+ * the answerer receives it via the 'datachannel' event.
+ *
+ * @example
+ * ```typescript
+ * // Offerer side (creates offer)
+ * const connection = new WebRTCRondevuConnection(
+ *   'conn-123',
+ *   'peer-username',
+ *   'chat.service@1.0.0'
+ * );
+ *
+ * await connection.ready; // Wait for local offer
+ * const sdp = connection.connection.localDescription!.sdp!;
+ * // Send sdp to signaling server...
+ *
+ * // Answerer side (receives offer)
+ * const connection = new WebRTCRondevuConnection(
+ *   'conn-123',
+ *   'peer-username',
+ *   'chat.service@1.0.0',
+ *   { type: 'offer', sdp: remoteOfferSdp }
+ * );
+ *
+ * await connection.ready; // Wait for local answer
+ * const answerSdp = connection.connection.localDescription!.sdp!;
+ * // Send answer to signaling server...
+ *
+ * // Both sides: Set up signaler and listen for state changes
+ * connection.setSignaler(signaler);
+ * connection.events.on('state-change', (state) => {
+ *   console.log('Connection state:', state);
+ * });
+ * ```
+ */
+export declare class RTCDurableConnection implements ConnectionInterface {
+    private readonly side;
+    readonly expiresAt: number;
+    readonly lastActive: number;
+    readonly events: EventBus<ConnectionEvents>;
+    readonly ready: Promise<void>;
+    private iceBin;
+    private context;
+    private readonly signaler;
+    private _conn;
+    private _state;
+    private _dataChannel;
+    private messageQueue;
+    constructor({ context, offer, signaler }: WebRTCRondevuConnectionOptions);
+    /**
+     * Getter method for retrieving the current connection.
+     *
+     * @return {RTCPeerConnection|null} The current connection instance.
+     */
+    get connection(): RTCPeerConnection | null;
+    /**
+     * Update connection state and emit state-change event
+     */
+    private setState;
+    /**
+     * Start ICE candidate exchange when gathering begins
+     */
+    private startIce;
+    /**
+     * Stop ICE candidate exchange when gathering completes
+     */
+    private stopIce;
+    /**
+     * Disconnects the current connection and cleans up resources.
+     * Closes the active connection if it exists, resets the connection instance to null,
+     * stops the ICE process, and updates the state to 'disconnected'.
+     *
+     * @return {void} No return value.
+     */
+    disconnect(): void;
+    /**
+     * Current connection state
+     */
+    get state(): "connected" | "disconnected" | "connecting";
+    /**
+     * Setup data channel event listeners
+     */
+    private setupDataChannelListeners;
+    /**
+     * Flush the message queue
+     */
+    private flushQueue;
+    /**
+     * Queue a message for sending when connection is established
+     *
+     * @param message - Message to queue (string or ArrayBuffer)
+     * @param options - Queue options (e.g., expiration time)
+     */
+    queueMessage(message: Message, options?: QueueMessageOptions): Promise<void>;
+    /**
+     * Send a message immediately
+     *
+     * @param message - Message to send (string or ArrayBuffer)
+     * @returns Promise resolving to true if sent successfully
+     */
+    sendMessage(message: Message): Promise<boolean>;
+}

package/dist/durable-connection.js

@@ -0,0 +1,244 @@
+import { isConnectionState, } from './types.js';
+import { EventBus } from './event-bus.js';
+import { createBin } from './bin.js';
+/**
+ * WebRTCRondevuConnection - WebRTC peer connection wrapper with Rondevu signaling
+ *
+ * Manages a WebRTC peer connection lifecycle including:
+ * - Automatic offer/answer creation based on role
+ * - ICE candidate exchange via Rondevu signaling server
+ * - Connection state management with type-safe events
+ * - Data channel creation and message handling
+ *
+ * The connection automatically determines its role (offerer or answerer) based on whether
+ * an offer is provided in the constructor. The offerer creates the data channel, while
+ * the answerer receives it via the 'datachannel' event.
+ *
+ * @example
+ * ```typescript
+ * // Offerer side (creates offer)
+ * const connection = new WebRTCRondevuConnection(
+ *   'conn-123',
+ *   'peer-username',
+ *   'chat.service@1.0.0'
+ * );
+ *
+ * await connection.ready; // Wait for local offer
+ * const sdp = connection.connection.localDescription!.sdp!;
+ * // Send sdp to signaling server...
+ *
+ * // Answerer side (receives offer)
+ * const connection = new WebRTCRondevuConnection(
+ *   'conn-123',
+ *   'peer-username',
+ *   'chat.service@1.0.0',
+ *   { type: 'offer', sdp: remoteOfferSdp }
+ * );
+ *
+ * await connection.ready; // Wait for local answer
+ * const answerSdp = connection.connection.localDescription!.sdp!;
+ * // Send answer to signaling server...
+ *
+ * // Both sides: Set up signaler and listen for state changes
+ * connection.setSignaler(signaler);
+ * connection.events.on('state-change', (state) => {
+ *   console.log('Connection state:', state);
+ * });
+ * ```
+ */
+export class RTCDurableConnection {
+    constructor({ context, offer, signaler }) {
+        this.expiresAt = 0;
+        this.lastActive = 0;
+        this.events = new EventBus();
+        this.iceBin = createBin();
+        this._conn = null;
+        this._state = 'disconnected';
+        this._dataChannel = null;
+        this.messageQueue = [];
+        this.context = context;
+        this.signaler = signaler;
+        this._conn = context.createPeerConnection();
+        this.side = offer ? 'answer' : 'offer';
+        // setup data channel
+        if (offer) {
+            this._conn.addEventListener('datachannel', e => {
+                this._dataChannel = e.channel;
+                this.setupDataChannelListeners(this._dataChannel);
+            });
+        }
+        else {
+            this._dataChannel = this._conn.createDataChannel('vu.ronde.protocol');
+            this.setupDataChannelListeners(this._dataChannel);
+        }
+        // setup description exchange
+        this.ready = offer
+            ? this._conn
+                .setRemoteDescription(offer)
+                .then(() => this._conn?.createAnswer())
+                .then(async (answer) => {
+                if (!answer || !this._conn)
+                    throw new Error('Connection disappeared');
+                await this._conn.setLocalDescription(answer);
+                return await signaler.setAnswer(answer);
+            })
+            : this._conn.createOffer().then(async (offer) => {
+                if (!this._conn)
+                    throw new Error('Connection disappeared');
+                await this._conn.setLocalDescription(offer);
+                return await signaler.setOffer(offer);
+            });
+        // propagate connection state changes
+        this._conn.addEventListener('connectionstatechange', () => {
+            console.log(this.side, 'connection state changed: ', this._conn.connectionState);
+            const state = isConnectionState(this._conn.connectionState)
+                ? this._conn.connectionState
+                : 'disconnected';
+            this.setState(state);
+        });
+        this._conn.addEventListener('iceconnectionstatechange', () => {
+            console.log(this.side, 'ice connection state changed: ', this._conn.iceConnectionState);
+        });
+        // start ICE candidate exchange when gathering begins
+        this._conn.addEventListener('icegatheringstatechange', () => {
+            if (this._conn.iceGatheringState === 'gathering') {
+                this.startIce();
+            }
+            else if (this._conn.iceGatheringState === 'complete') {
+                this.stopIce();
+            }
+        });
+    }
+    /**
+     * Getter method for retrieving the current connection.
+     *
+     * @return {RTCPeerConnection|null} The current connection instance.
+     */
+    get connection() {
+        return this._conn;
+    }
+    /**
+     * Update connection state and emit state-change event
+     */
+    setState(state) {
+        this._state = state;
+        this.events.emit('state-change', state);
+    }
+    /**
+     * Start ICE candidate exchange when gathering begins
+     */
+    startIce() {
+        const listener = ({ candidate }) => {
+            if (candidate)
+                this.signaler.addIceCandidate(candidate);
+        };
+        if (!this._conn)
+            throw new Error('Connection disappeared');
+        this._conn.addEventListener('icecandidate', listener);
+        this.iceBin(this.signaler.addListener((candidate) => this._conn?.addIceCandidate(candidate)), () => this._conn?.removeEventListener('icecandidate', listener));
+    }
+    /**
+     * Stop ICE candidate exchange when gathering completes
+     */
+    stopIce() {
+        this.iceBin.clean();
+    }
+    /**
+     * Disconnects the current connection and cleans up resources.
+     * Closes the active connection if it exists, resets the connection instance to null,
+     * stops the ICE process, and updates the state to 'disconnected'.
+     *
+     * @return {void} No return value.
+     */
+    disconnect() {
+        this._conn?.close();
+        this._conn = null;
+        this.stopIce();
+        this.setState('disconnected');
+    }
+    /**
+     * Current connection state
+     */
+    get state() {
+        return this._state;
+    }
+    /**
+     * Setup data channel event listeners
+     */
+    setupDataChannelListeners(channel) {
+        channel.addEventListener('message', e => {
+            this.events.emit('message', e.data);
+        });
+        channel.addEventListener('open', () => {
+            // Channel opened - flush queued messages
+            this.flushQueue().catch(err => {
+                console.error('Failed to flush message queue:', err);
+            });
+        });
+        channel.addEventListener('error', err => {
+            console.error('Data channel error:', err);
+        });
+        channel.addEventListener('close', () => {
+            console.log('Data channel closed');
+        });
+    }
+    /**
+     * Flush the message queue
+     */
+    async flushQueue() {
+        while (this.messageQueue.length > 0 && this._state === 'connected') {
+            const item = this.messageQueue.shift();
+            // Check expiration
+            if (item.options.expiresAt && Date.now() > item.options.expiresAt) {
+                continue;
+            }
+            const success = await this.sendMessage(item.message);
+            if (!success) {
+                // Re-queue on failure
+                this.messageQueue.unshift(item);
+                break;
+            }
+        }
+    }
+    /**
+     * Queue a message for sending when connection is established
+     *
+     * @param message - Message to queue (string or ArrayBuffer)
+     * @param options - Queue options (e.g., expiration time)
+     */
+    async queueMessage(message, options = {}) {
+        this.messageQueue.push({
+            message,
+            options,
+            timestamp: Date.now()
+        });
+        // Try immediate send if connected
+        if (this._state === 'connected') {
+            await this.flushQueue();
+        }
+    }
+    /**
+     * Send a message immediately
+     *
+     * @param message - Message to send (string or ArrayBuffer)
+     * @returns Promise resolving to true if sent successfully
+     */
+    async sendMessage(message) {
+        if (this._state !== 'connected' || !this._dataChannel) {
+            return false;
+        }
+        if (this._dataChannel.readyState !== 'open') {
+            return false;
+        }
+        try {
+            // TypeScript has trouble with the union type, so we cast to any
+            // Both string and ArrayBuffer are valid for RTCDataChannel.send()
+            this._dataChannel.send(message);
+            return true;
+        }
+        catch (err) {
+            console.error('Send failed:', err);
+            return false;
+        }
+    }
+}

package/dist/index.d.ts

@@ -5,10 +5,11 @@
 export { EventBus } from './event-bus.js';
 export { RondevuAPI } from './api.js';
 export { RondevuService } from './rondevu-service.js';
-export { RondevuSignaler } from './signaler.js';
+export { RondevuSignaler } from './rondevu-signaler.js';
+export { WebRTCContext } from './webrtc-context.js';
+export { RTCDurableConnection } from './durable-connection';
 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';
@@ -16,3 +17,4 @@ 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';
+export type { PollingConfig } from './rondevu-signaler.js';

package/dist/index.js

@@ -5,8 +5,9 @@
 export { EventBus } from './event-bus.js';
 export { RondevuAPI } from './api.js';
 export { RondevuService } from './rondevu-service.js';
-export { RondevuSignaler } from './signaler.js';
+export { RondevuSignaler } from './rondevu-signaler.js';
+export { WebRTCContext } from './webrtc-context.js';
+export { RTCDurableConnection } from './durable-connection';
 export { ServiceHost } from './service-host.js';
 export { ServiceClient } from './service-client.js';
-export { WebRTCRondevuConnection } from './connection.js';
 export { createBin } from './bin.js';

package/dist/quick-start.d.ts

@@ -0,0 +1,29 @@
+import { RondevuService } from './rondevu-service.js';
+import { Keypair } from './api.js';
+export interface QuickStartOptions {
+    apiUrl: string;
+    username?: string;
+    keypair?: Keypair;
+}
+/**
+ * Quick start helper for initializing Rondevu service
+ *
+ * Simplifies initialization by:
+ * - Auto-generating username if not provided
+ * - Auto-generating keypair if not provided
+ * - Registering with the server
+ * - Claiming the username
+ *
+ * @example
+ * ```typescript
+ * // Simple usage with auto-generated username
+ * const service = await quickStart({ apiUrl: 'https://api.ronde.vu' })
+ *
+ * // With custom username
+ * const service = await quickStart({
+ *     apiUrl: 'https://api.ronde.vu',
+ *     username: 'my-username'
+ * })
+ * ```
+ */
+export declare function quickStart(options: QuickStartOptions): Promise<RondevuService>;

package/dist/quick-start.js

@@ -0,0 +1,44 @@
+import { RondevuService } from './rondevu-service.js';
+/**
+ * Quick start helper for initializing Rondevu service
+ *
+ * Simplifies initialization by:
+ * - Auto-generating username if not provided
+ * - Auto-generating keypair if not provided
+ * - Registering with the server
+ * - Claiming the username
+ *
+ * @example
+ * ```typescript
+ * // Simple usage with auto-generated username
+ * const service = await quickStart({ apiUrl: 'https://api.ronde.vu' })
+ *
+ * // With custom username
+ * const service = await quickStart({
+ *     apiUrl: 'https://api.ronde.vu',
+ *     username: 'my-username'
+ * })
+ * ```
+ */
+export async function quickStart(options) {
+    // Generate username if not provided
+    const username = options.username || `user-${generateId()}`;
+    // Create service
+    const serviceOptions = {
+        apiUrl: options.apiUrl,
+        username,
+        keypair: options.keypair
+    };
+    const service = new RondevuService(serviceOptions);
+    // Initialize (generates keypair and registers)
+    await service.initialize();
+    // Claim username
+    await service.claimUsername();
+    return service;
+}
+/**
+ * Generate a random ID
+ */
+function generateId() {
+    return Math.random().toString(36).substring(2, 10);
+}

package/dist/rondevu-context.d.ts

@@ -0,0 +1,10 @@
+import { RondevuService } from "./rondevu-service";
+import { RTCDurableConnection } from "./durable-connection";
+export declare class RondevuContext {
+    readonly rondevu: RondevuService;
+    readonly rtcConfig: RTCConfiguration;
+    private readonly context;
+    private readonly connections;
+    constructor(rondevu: RondevuService, rtcConfig: RTCConfiguration);
+    createConnection(service: string, host?: string, offer?: RTCSessionDescriptionInit): RTCDurableConnection;
+}

package/dist/rondevu-context.js

@@ -0,0 +1,20 @@
+import { WebRTCContext } from "./webrtc-context";
+import { RTCDurableConnection } from "./durable-connection";
+import { RondevuSignaler } from "./rondevu-signaler";
+export class RondevuContext {
+    constructor(rondevu, rtcConfig) {
+        this.rondevu = rondevu;
+        this.rtcConfig = rtcConfig;
+        this.connections = [];
+        this.context = new WebRTCContext(rtcConfig);
+    }
+    createConnection(service, host, offer) {
+        const conn = new RTCDurableConnection({
+            context: this.context,
+            offer,
+            signaler: new RondevuSignaler(this.rondevu, service, host)
+        });
+        this.connections.push(conn);
+        return conn;
+    }
+}