@xtr-dev/rondevu-client 0.9.1 → 0.10.0

package/dist/service-host.d.ts

@@ -0,0 +1,101 @@
+import { WebRTCRondevuConnection } from './connection.js';
+import { RondevuService } from './rondevu-service.js';
+import { EventBus } from './event-bus.js';
+import { ConnectionInterface } from './types.js';
+export interface ServiceHostOptions {
+    service: string;
+    rondevuService: RondevuService;
+    maxPeers?: number;
+    ttl?: number;
+    isPublic?: boolean;
+    metadata?: Record<string, any>;
+}
+export interface ServiceHostEvents {
+    connection: ConnectionInterface;
+    'connection-closed': {
+        connectionId: string;
+        reason: string;
+    };
+    error: Error;
+}
+/**
+ * ServiceHost - Manages a pool of WebRTC offers for a service
+ *
+ * Maintains up to maxPeers concurrent offers, automatically replacing
+ * them when connections are established or expire.
+ *
+ * @example
+ * ```typescript
+ * const rondevuService = new RondevuService({
+ *   apiUrl: 'https://signal.example.com',
+ *   username: 'myusername',
+ * })
+ *
+ * await rondevuService.initialize()
+ * await rondevuService.claimUsername()
+ *
+ * const host = new ServiceHost({
+ *   service: 'chat.app@1.0.0',
+ *   rondevuService,
+ *   maxPeers: 5,
+ * })
+ *
+ * await host.start()
+ *
+ * host.events.on('connection', (conn) => {
+ *   console.log('New connection:', conn.id)
+ *   conn.events.on('message', (msg) => {
+ *     console.log('Message:', msg)
+ *   })
+ * })
+ * ```
+ */
+export declare class ServiceHost {
+    private connections;
+    private readonly service;
+    private readonly rondevuService;
+    private readonly maxPeers;
+    private readonly ttl;
+    private readonly isPublic;
+    private readonly metadata?;
+    private readonly bin;
+    private isStarted;
+    readonly events: EventBus<ServiceHostEvents>;
+    constructor(options: ServiceHostOptions);
+    /**
+     * Start hosting the service - creates initial pool of offers
+     */
+    start(): Promise<void>;
+    /**
+     * Stop hosting - closes all connections and cleans up
+     */
+    stop(): void;
+    /**
+     * Get current number of active connections
+     */
+    getConnectionCount(): number;
+    /**
+     * Get current number of pending offers
+     */
+    getPendingOfferCount(): number;
+    /**
+     * Fill the offer pool up to maxPeers
+     */
+    private fillOfferPool;
+    /**
+     * Create a single offer and publish it
+     */
+    private createOffer;
+    /**
+     * Handle connection state changes
+     */
+    private handleConnectionStateChange;
+    /**
+     * Get all active connections
+     */
+    getConnections(): WebRTCRondevuConnection[];
+    /**
+     * Get a specific connection by ID
+     */
+    getConnection(connectionId: string): WebRTCRondevuConnection | undefined;
+}

package/dist/service-host.js

@@ -0,0 +1,185 @@
+import { WebRTCRondevuConnection } from './connection.js';
+import { WebRTCContext } from './webrtc-context.js';
+import { RondevuSignaler } from './signaler.js';
+import { NoOpSignaler } from './noop-signaler.js';
+import { EventBus } from './event-bus.js';
+import { createBin } from './bin.js';
+/**
+ * ServiceHost - Manages a pool of WebRTC offers for a service
+ *
+ * Maintains up to maxPeers concurrent offers, automatically replacing
+ * them when connections are established or expire.
+ *
+ * @example
+ * ```typescript
+ * const rondevuService = new RondevuService({
+ *   apiUrl: 'https://signal.example.com',
+ *   username: 'myusername',
+ * })
+ *
+ * await rondevuService.initialize()
+ * await rondevuService.claimUsername()
+ *
+ * const host = new ServiceHost({
+ *   service: 'chat.app@1.0.0',
+ *   rondevuService,
+ *   maxPeers: 5,
+ * })
+ *
+ * await host.start()
+ *
+ * host.events.on('connection', (conn) => {
+ *   console.log('New connection:', conn.id)
+ *   conn.events.on('message', (msg) => {
+ *     console.log('Message:', msg)
+ *   })
+ * })
+ * ```
+ */
+export class ServiceHost {
+    constructor(options) {
+        this.connections = new Map();
+        this.bin = createBin();
+        this.isStarted = false;
+        this.events = new EventBus();
+        this.service = options.service;
+        this.rondevuService = options.rondevuService;
+        this.maxPeers = options.maxPeers || 20;
+        this.ttl = options.ttl || 300000;
+        this.isPublic = options.isPublic !== false;
+        this.metadata = options.metadata;
+    }
+    /**
+     * Start hosting the service - creates initial pool of offers
+     */
+    async start() {
+        if (this.isStarted) {
+            throw new Error('ServiceHost already started');
+        }
+        this.isStarted = true;
+        await this.fillOfferPool();
+    }
+    /**
+     * Stop hosting - closes all connections and cleans up
+     */
+    stop() {
+        this.isStarted = false;
+        this.connections.forEach(conn => conn.disconnect());
+        this.connections.clear();
+        this.bin.clean();
+    }
+    /**
+     * Get current number of active connections
+     */
+    getConnectionCount() {
+        return Array.from(this.connections.values()).filter(conn => conn.state === 'connected')
+            .length;
+    }
+    /**
+     * Get current number of pending offers
+     */
+    getPendingOfferCount() {
+        return Array.from(this.connections.values()).filter(conn => conn.state === 'connecting')
+            .length;
+    }
+    /**
+     * Fill the offer pool up to maxPeers
+     */
+    async fillOfferPool() {
+        const currentOffers = this.connections.size;
+        const needed = this.maxPeers - currentOffers;
+        if (needed <= 0) {
+            return;
+        }
+        // Create multiple offers in parallel
+        const offerPromises = [];
+        for (let i = 0; i < needed; i++) {
+            offerPromises.push(this.createOffer());
+        }
+        await Promise.allSettled(offerPromises);
+    }
+    /**
+     * Create a single offer and publish it
+     */
+    async createOffer() {
+        try {
+            // Create temporary context with NoOp signaler
+            const tempContext = new WebRTCContext(new NoOpSignaler());
+            // Create connection (offerer role)
+            const conn = new WebRTCRondevuConnection({
+                id: `${this.service}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+                service: this.service,
+                offer: null,
+                context: tempContext,
+            });
+            // Wait for offer to be created
+            await conn.ready;
+            // Get offer SDP
+            if (!conn.connection?.localDescription?.sdp) {
+                throw new Error('Failed to create offer SDP');
+            }
+            const sdp = conn.connection.localDescription.sdp;
+            // Publish service offer
+            const service = await this.rondevuService.publishService({
+                serviceFqn: this.service,
+                sdp,
+                ttl: this.ttl,
+                isPublic: this.isPublic,
+                metadata: this.metadata,
+            });
+            // Replace with real signaler now that we have offerId
+            const realSignaler = new RondevuSignaler(this.rondevuService.getAPI(), service.offerId);
+            tempContext.signaler = realSignaler;
+            // Track connection
+            this.connections.set(conn.id, conn);
+            // Listen for state changes
+            const cleanup = conn.events.on('state-change', state => {
+                this.handleConnectionStateChange(conn, state);
+            });
+            this.bin(cleanup);
+        }
+        catch (error) {
+            this.events.emit('error', error);
+        }
+    }
+    /**
+     * Handle connection state changes
+     */
+    handleConnectionStateChange(conn, state) {
+        if (state === 'connected') {
+            // Connection established - emit event
+            this.events.emit('connection', conn);
+            // Create new offer to replace this one
+            if (this.isStarted) {
+                this.fillOfferPool().catch(error => {
+                    this.events.emit('error', error);
+                });
+            }
+        }
+        else if (state === 'disconnected') {
+            // Connection closed - remove and create new offer
+            this.connections.delete(conn.id);
+            this.events.emit('connection-closed', {
+                connectionId: conn.id,
+                reason: state,
+            });
+            if (this.isStarted) {
+                this.fillOfferPool().catch(error => {
+                    this.events.emit('error', error);
+                });
+            }
+        }
+    }
+    /**
+     * Get all active connections
+     */
+    getConnections() {
+        return Array.from(this.connections.values());
+    }
+    /**
+     * Get a specific connection by ID
+     */
+    getConnection(connectionId) {
+        return this.connections.get(connectionId);
+    }
+}

package/dist/signaler.d.ts

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,89 @@
+/**
+ * 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/types.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Core connection types
+ */
+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 {
+    id: string;
+    service: string;
+    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> | 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/types.js

@@ -0,0 +1,2 @@
+export const ConnectionStates = ['connected', 'disconnected', 'connecting'];
+export const isConnectionState = (state) => ConnectionStates.includes(state);

package/dist/webrtc-context.d.ts

@@ -0,0 +1,6 @@
+import { Signaler } from './types';
+export declare class WebRTCContext {
+    readonly signaler: Signaler;
+    constructor(signaler: Signaler);
+    createPeerConnection(): RTCPeerConnection;
+}

package/dist/webrtc-context.js

@@ -0,0 +1,34 @@
+export class WebRTCContext {
+    constructor(signaler) {
+        this.signaler = signaler;
+    }
+    createPeerConnection() {
+        return new RTCPeerConnection({
+            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',
+                },
+            ],
+        });
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xtr-dev/rondevu-client",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "TypeScript client for Rondevu with durable WebRTC connections, automatic reconnection, and message queuing",
   "type": "module",
   "main": "dist/index.js",
@@ -8,6 +8,10 @@
   "scripts": {
     "build": "tsc",
     "typecheck": "tsc --noEmit",
+    "dev": "vite",
+    "lint": "eslint src demo --ext .ts,.tsx,.js",
+    "lint:fix": "eslint src demo --ext .ts,.tsx,.js --fix",
+    "format": "prettier --write \"src/**/*.{ts,tsx,js}\" \"demo/**/*.{ts,tsx,js,html}\"",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -20,7 +24,17 @@
   "author": "",
   "license": "MIT",
   "devDependencies": {
-    "typescript": "^5.9.3"
+    "@eslint/js": "^9.39.1",
+    "@typescript-eslint/eslint-plugin": "^8.48.1",
+    "@typescript-eslint/parser": "^8.48.1",
+    "eslint": "^9.39.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-unicorn": "^62.0.0",
+    "globals": "^16.5.0",
+    "prettier": "^3.7.4",
+    "typescript": "^5.9.3",
+    "vite": "^7.2.6"
   },
   "files": [
     "dist",

package/dist/auth.d.ts

@@ -1,20 +0,0 @@
-export interface Credentials {
-    peerId: string;
-    secret: string;
-}
-export type FetchFunction = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-export declare class RondevuAuth {
-    private baseUrl;
-    private fetchFn;
-    constructor(baseUrl: string, fetchFn?: FetchFunction);
-    /**
-     * Register a new peer and receive credentials
-     * Generates a cryptographically random peer ID (128-bit)
-     * @throws Error if registration fails
-     */
-    register(): Promise<Credentials>;
-    /**
-     * Create Authorization header value
-     */
-    static createAuthHeader(credentials: Credentials): string;
-}

package/dist/auth.js

@@ -1,41 +0,0 @@
-export class RondevuAuth {
-    constructor(baseUrl, fetchFn) {
-        this.baseUrl = baseUrl;
-        // Use provided fetch or fall back to global fetch
-        this.fetchFn = fetchFn || ((...args) => {
-            if (typeof globalThis.fetch === 'function') {
-                return globalThis.fetch(...args);
-            }
-            throw new Error('fetch is not available. Please provide a fetch implementation in the constructor options.');
-        });
-    }
-    /**
-     * Register a new peer and receive credentials
-     * Generates a cryptographically random peer ID (128-bit)
-     * @throws Error if registration fails
-     */
-    async register() {
-        const response = await this.fetchFn(`${this.baseUrl}/register`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({}),
-        });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Registration failed: ${error.error || response.statusText}`);
-        }
-        const data = await response.json();
-        return {
-            peerId: data.peerId,
-            secret: data.secret,
-        };
-    }
-    /**
-     * Create Authorization header value
-     */
-    static createAuthHeader(credentials) {
-        return `Bearer ${credentials.peerId}:${credentials.secret}`;
-    }
-}