@xtr-dev/rondevu-client 0.9.1 → 0.10.0

package/dist/service-pool.js

@@ -1,417 +0,0 @@
-import { RondevuOffers } from './offers.js';
-import { RondevuUsername } from './usernames.js';
-import RondevuPeer from './peer/index.js';
-import { OfferPool } from './offer-pool.js';
-/**
- * Manages a pooled service with multiple concurrent connections
- *
- * ServicePool coordinates offer creation, answer polling, and connection
- * management for services that need to handle multiple simultaneous connections.
- */
-export class ServicePool {
-    constructor(baseUrl, credentials, options) {
-        this.baseUrl = baseUrl;
-        this.credentials = credentials;
-        this.options = options;
-        this.connections = new Map();
-        this.peerConnections = new Map();
-        this.status = {
-            activeOffers: 0,
-            activeConnections: 0,
-            totalConnectionsHandled: 0,
-            failedOfferCreations: 0
-        };
-        this.offersApi = new RondevuOffers(baseUrl, credentials);
-        this.usernameApi = new RondevuUsername(baseUrl);
-    }
-    /**
-     * Start the pooled service
-     */
-    async start() {
-        const poolSize = this.options.poolSize || 1;
-        // 1. Create initial service (publishes first offer)
-        const service = await this.publishInitialService();
-        this.serviceId = service.serviceId;
-        this.uuid = service.uuid;
-        // 2. Create additional offers for pool (poolSize - 1)
-        const additionalOffers = [];
-        const additionalPeerConnections = [];
-        const additionalDataChannels = [];
-        if (poolSize > 1) {
-            try {
-                const result = await this.createOffers(poolSize - 1);
-                additionalOffers.push(...result.offers);
-                additionalPeerConnections.push(...result.peerConnections);
-                additionalDataChannels.push(...result.dataChannels);
-            }
-            catch (error) {
-                this.handleError(error, 'initial-offer-creation');
-            }
-        }
-        // 3. Initialize OfferPool with all offers
-        this.offerPool = new OfferPool(this.offersApi, {
-            poolSize,
-            pollingInterval: this.options.pollingInterval || 2000,
-            onAnswered: (answer) => this.handleConnection(answer),
-            onRefill: (count) => this.createOffers(count),
-            onError: (err, ctx) => this.handleError(err, ctx)
-        });
-        // Add all offers to pool with their peer connections and data channels
-        const allOffers = [
-            { id: service.offerId, peerId: this.credentials.peerId, sdp: service.offerSdp, topics: [], expiresAt: service.expiresAt, lastSeen: Date.now() },
-            ...additionalOffers
-        ];
-        const allPeerConnections = [
-            service.peerConnection,
-            ...additionalPeerConnections
-        ];
-        const allDataChannels = [
-            service.dataChannel,
-            ...additionalDataChannels
-        ];
-        await this.offerPool.addOffers(allOffers, allPeerConnections, allDataChannels);
-        // 4. Start polling
-        await this.offerPool.start();
-        // Update status
-        this.updateStatus();
-        // 5. Return handle
-        return {
-            serviceId: this.serviceId,
-            uuid: this.uuid,
-            offerId: service.offerId,
-            unpublish: () => this.stop(),
-            getStatus: () => this.getStatus(),
-            addOffers: (count) => this.manualRefill(count)
-        };
-    }
-    /**
-     * Stop the pooled service and clean up
-     */
-    async stop() {
-        // 1. Stop accepting new connections
-        if (this.offerPool) {
-            await this.offerPool.stop();
-        }
-        // 2. Close peer connections from the pool
-        if (this.offerPool) {
-            const poolPeerConnections = this.offerPool.getActivePeerConnections();
-            poolPeerConnections.forEach(pc => {
-                try {
-                    pc.close();
-                }
-                catch {
-                    // Ignore errors during cleanup
-                }
-            });
-        }
-        // 3. Delete remaining offers
-        if (this.offerPool) {
-            const offerIds = this.offerPool.getActiveOfferIds();
-            await Promise.allSettled(offerIds.map(id => this.offersApi.delete(id).catch(() => { })));
-        }
-        // 4. Close active connections
-        const closePromises = Array.from(this.connections.values()).map(async (conn) => {
-            try {
-                // Give a brief moment for graceful closure
-                await new Promise(resolve => setTimeout(resolve, 100));
-                conn.peer.pc.close();
-            }
-            catch {
-                // Ignore errors during cleanup
-            }
-        });
-        await Promise.allSettled(closePromises);
-        // 5. Delete service if we have a serviceId
-        if (this.serviceId) {
-            try {
-                const response = await fetch(`${this.baseUrl}/services/${this.serviceId}`, {
-                    method: 'DELETE',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'Authorization': `Bearer ${this.credentials.peerId}:${this.credentials.secret}`
-                    },
-                    body: JSON.stringify({ username: this.options.username })
-                });
-                if (!response.ok) {
-                    console.error('Failed to delete service:', await response.text());
-                }
-            }
-            catch (error) {
-                console.error('Error deleting service:', error);
-            }
-        }
-        // Clear all state
-        this.connections.clear();
-        this.offerPool = undefined;
-    }
-    /**
-     * Handle an answered offer by setting up the connection
-     */
-    async handleConnection(answer) {
-        const connectionId = this.generateConnectionId();
-        try {
-            // Use the existing peer connection from the pool
-            const peer = new RondevuPeer(this.offersApi, this.options.rtcConfig || {
-                iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
-            }, answer.peerConnection // Use the existing peer connection
-            );
-            peer.role = 'offerer';
-            peer.offerId = answer.offerId;
-            // Verify peer connection is in correct state
-            if (peer.pc.signalingState !== 'have-local-offer') {
-                console.error('Peer connection state info:', {
-                    signalingState: peer.pc.signalingState,
-                    connectionState: peer.pc.connectionState,
-                    iceConnectionState: peer.pc.iceConnectionState,
-                    iceGatheringState: peer.pc.iceGatheringState,
-                    hasLocalDescription: !!peer.pc.localDescription,
-                    hasRemoteDescription: !!peer.pc.remoteDescription,
-                    localDescriptionType: peer.pc.localDescription?.type,
-                    remoteDescriptionType: peer.pc.remoteDescription?.type,
-                    offerId: answer.offerId
-                });
-                throw new Error(`Invalid signaling state: ${peer.pc.signalingState}. Expected 'have-local-offer' to set remote answer.`);
-            }
-            // Set remote description (the answer)
-            await peer.pc.setRemoteDescription({
-                type: 'answer',
-                sdp: answer.sdp
-            });
-            // Use the data channel we created when making the offer
-            if (!answer.dataChannel) {
-                throw new Error('No data channel found for answered offer');
-            }
-            const channel = answer.dataChannel;
-            // Wait for the channel to open (it was created when we made the offer)
-            if (channel.readyState !== 'open') {
-                await new Promise((resolve, reject) => {
-                    const timeout = setTimeout(() => reject(new Error('Timeout waiting for data channel to open')), 30000);
-                    channel.onopen = () => {
-                        clearTimeout(timeout);
-                        resolve();
-                    };
-                    channel.onerror = (error) => {
-                        clearTimeout(timeout);
-                        reject(new Error('Data channel error'));
-                    };
-                });
-            }
-            // Register connection
-            this.connections.set(connectionId, {
-                peer,
-                channel,
-                connectedAt: Date.now(),
-                offerId: answer.offerId
-            });
-            this.status.activeConnections++;
-            this.status.totalConnectionsHandled++;
-            // Setup cleanup on disconnect
-            peer.on('disconnected', () => {
-                this.connections.delete(connectionId);
-                this.status.activeConnections--;
-                this.updateStatus();
-            });
-            peer.on('failed', () => {
-                this.connections.delete(connectionId);
-                this.status.activeConnections--;
-                this.updateStatus();
-            });
-            // Update status
-            this.updateStatus();
-            // Invoke user handler (wrapped in try-catch)
-            try {
-                this.options.handler(channel, peer, connectionId);
-            }
-            catch (handlerError) {
-                this.handleError(handlerError, 'handler');
-            }
-        }
-        catch (error) {
-            this.handleError(error, 'connection-setup');
-        }
-    }
-    /**
-     * Create multiple offers
-     */
-    async createOffers(count) {
-        if (count <= 0) {
-            return { offers: [], peerConnections: [], dataChannels: [] };
-        }
-        // Server supports max 10 offers per request
-        const batchSize = Math.min(count, 10);
-        const offers = [];
-        const peerConnections = [];
-        const dataChannels = [];
-        try {
-            // Create peer connections and generate offers
-            const offerRequests = [];
-            for (let i = 0; i < batchSize; i++) {
-                const pc = new RTCPeerConnection(this.options.rtcConfig || {
-                    iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
-                });
-                // Create data channel (required for offers) and save reference
-                const channel = pc.createDataChannel('rondevu-service');
-                dataChannels.push(channel);
-                // Create offer
-                const offer = await pc.createOffer();
-                await pc.setLocalDescription(offer);
-                if (!offer.sdp) {
-                    pc.close();
-                    throw new Error('Failed to generate SDP');
-                }
-                offerRequests.push({
-                    sdp: offer.sdp,
-                    topics: [], // V2 doesn't use topics
-                    ttl: this.options.ttl
-                });
-                // Keep peer connection alive - DO NOT CLOSE
-                peerConnections.push(pc);
-            }
-            // Batch create offers
-            const createdOffers = await this.offersApi.create(offerRequests);
-            offers.push(...createdOffers);
-            // Set up ICE candidate handlers AFTER we have offer IDs
-            for (let i = 0; i < peerConnections.length; i++) {
-                const pc = peerConnections[i];
-                const offerId = createdOffers[i].id;
-                pc.onicecandidate = async (event) => {
-                    if (event.candidate) {
-                        const candidateData = event.candidate.toJSON();
-                        if (candidateData.candidate && candidateData.candidate !== '') {
-                            try {
-                                await this.offersApi.addIceCandidates(offerId, [candidateData]);
-                            }
-                            catch (err) {
-                                console.error('Error sending ICE candidate:', err);
-                            }
-                        }
-                    }
-                };
-            }
-        }
-        catch (error) {
-            // Close any created peer connections on error
-            peerConnections.forEach(pc => pc.close());
-            this.status.failedOfferCreations++;
-            this.handleError(error, 'offer-creation');
-            throw error;
-        }
-        return { offers, peerConnections, dataChannels };
-    }
-    /**
-     * Publish the initial service (creates first offer)
-     */
-    async publishInitialService() {
-        const { username, privateKey, serviceFqn, rtcConfig, isPublic, metadata, ttl } = this.options;
-        // Create peer connection for initial offer
-        const pc = new RTCPeerConnection(rtcConfig || {
-            iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
-        });
-        const dataChannel = pc.createDataChannel('rondevu-service');
-        // Create offer
-        const offer = await pc.createOffer();
-        await pc.setLocalDescription(offer);
-        if (!offer.sdp) {
-            pc.close();
-            throw new Error('Failed to generate SDP');
-        }
-        // Store the SDP
-        const offerSdp = offer.sdp;
-        // Create signature
-        const timestamp = Date.now();
-        const message = `publish:${username}:${serviceFqn}:${timestamp}`;
-        const signature = await this.usernameApi.signMessage(message, privateKey);
-        // Publish service
-        const response = await fetch(`${this.baseUrl}/services`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${this.credentials.peerId}:${this.credentials.secret}`
-            },
-            body: JSON.stringify({
-                username,
-                serviceFqn,
-                sdp: offerSdp,
-                ttl,
-                isPublic,
-                metadata,
-                signature,
-                message
-            })
-        });
-        if (!response.ok) {
-            pc.close();
-            const error = await response.json();
-            throw new Error(error.error || 'Failed to publish service');
-        }
-        const data = await response.json();
-        // Set up ICE candidate handler now that we have the offer ID
-        pc.onicecandidate = async (event) => {
-            if (event.candidate) {
-                const candidateData = event.candidate.toJSON();
-                if (candidateData.candidate && candidateData.candidate !== '') {
-                    try {
-                        await this.offersApi.addIceCandidates(data.offerId, [candidateData]);
-                    }
-                    catch (err) {
-                        console.error('Error sending ICE candidate:', err);
-                    }
-                }
-            }
-        };
-        return {
-            serviceId: data.serviceId,
-            uuid: data.uuid,
-            offerId: data.offerId,
-            offerSdp,
-            expiresAt: data.expiresAt,
-            peerConnection: pc, // Keep peer connection alive
-            dataChannel // Keep data channel alive
-        };
-    }
-    /**
-     * Manually add offers to the pool
-     */
-    async manualRefill(count) {
-        if (!this.offerPool) {
-            throw new Error('Pool not started');
-        }
-        const result = await this.createOffers(count);
-        await this.offerPool.addOffers(result.offers, result.peerConnections, result.dataChannels);
-        this.updateStatus();
-    }
-    /**
-     * Get current pool status
-     */
-    getStatus() {
-        return { ...this.status };
-    }
-    /**
-     * Update status and notify listeners
-     */
-    updateStatus() {
-        if (this.offerPool) {
-            this.status.activeOffers = this.offerPool.getActiveOfferCount();
-        }
-        if (this.options.onPoolStatus) {
-            this.options.onPoolStatus(this.getStatus());
-        }
-    }
-    /**
-     * Handle errors
-     */
-    handleError(error, context) {
-        if (this.options.onError) {
-            this.options.onError(error, context);
-        }
-        else {
-            console.error(`ServicePool error (${context}):`, error);
-        }
-    }
-    /**
-     * Generate a unique connection ID
-     */
-    generateConnectionId() {
-        return `conn-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    }
-}

package/dist/usernames.d.ts

@@ -1,79 +0,0 @@
-/**
- * Username claim result
- */
-export interface UsernameClaimResult {
-    username: string;
-    publicKey: string;
-    privateKey: string;
-    claimedAt: number;
-    expiresAt: number;
-}
-/**
- * Username availability check result
- */
-export interface UsernameCheckResult {
-    username: string;
-    available: boolean;
-    claimedAt?: number;
-    expiresAt?: number;
-    publicKey?: string;
-}
-/**
- * Rondevu Username API
- * Handles username claiming with Ed25519 cryptographic proof
- */
-export declare class RondevuUsername {
-    private baseUrl;
-    constructor(baseUrl: string);
-    /**
-     * Generates an Ed25519 keypair for username claiming
-     */
-    generateKeypair(): Promise<{
-        publicKey: string;
-        privateKey: string;
-    }>;
-    /**
-     * Signs a message with an Ed25519 private key
-     */
-    signMessage(message: string, privateKeyBase64: string): Promise<string>;
-    /**
-     * Claims a username
-     * Generates a new keypair if one is not provided
-     */
-    claimUsername(username: string, existingKeypair?: {
-        publicKey: string;
-        privateKey: string;
-    }): Promise<UsernameClaimResult>;
-    /**
-     * Checks if a username is available
-     */
-    checkUsername(username: string): Promise<UsernameCheckResult>;
-    /**
-     * Helper: Save keypair to localStorage
-     * WARNING: This stores the private key in localStorage which is not the most secure
-     * For production use, consider using IndexedDB with encryption or hardware security modules
-     */
-    saveKeypairToStorage(username: string, publicKey: string, privateKey: string): void;
-    /**
-     * Helper: Load keypair from localStorage
-     */
-    loadKeypairFromStorage(username: string): {
-        publicKey: string;
-        privateKey: string;
-    } | null;
-    /**
-     * Helper: Delete keypair from localStorage
-     */
-    deleteKeypairFromStorage(username: string): void;
-    /**
-     * Export keypair as JSON string (for backup)
-     */
-    exportKeypair(publicKey: string, privateKey: string): string;
-    /**
-     * Import keypair from JSON string
-     */
-    importKeypair(json: string): {
-        publicKey: string;
-        privateKey: string;
-    };
-}

package/dist/usernames.js

@@ -1,153 +0,0 @@
-import * as ed25519 from '@noble/ed25519';
-// Set SHA-512 hash function for ed25519 (required in @noble/ed25519 v3+)
-// Uses built-in WebCrypto API which only provides async digest
-// We use the async ed25519 functions (signAsync, verifyAsync, getPublicKeyAsync)
-ed25519.hashes.sha512Async = async (message) => {
-    return new Uint8Array(await crypto.subtle.digest('SHA-512', message));
-};
-/**
- * Convert Uint8Array to base64 string
- */
-function bytesToBase64(bytes) {
-    const binString = Array.from(bytes, (byte) => String.fromCodePoint(byte)).join('');
-    return btoa(binString);
-}
-/**
- * Convert base64 string to Uint8Array
- */
-function base64ToBytes(base64) {
-    const binString = atob(base64);
-    return Uint8Array.from(binString, (char) => char.codePointAt(0));
-}
-/**
- * Rondevu Username API
- * Handles username claiming with Ed25519 cryptographic proof
- */
-export class RondevuUsername {
-    constructor(baseUrl) {
-        this.baseUrl = baseUrl;
-    }
-    /**
-     * Generates an Ed25519 keypair for username claiming
-     */
-    async generateKeypair() {
-        const privateKey = ed25519.utils.randomSecretKey();
-        const publicKey = await ed25519.getPublicKeyAsync(privateKey);
-        return {
-            publicKey: bytesToBase64(publicKey),
-            privateKey: bytesToBase64(privateKey)
-        };
-    }
-    /**
-     * Signs a message with an Ed25519 private key
-     */
-    async signMessage(message, privateKeyBase64) {
-        const privateKey = base64ToBytes(privateKeyBase64);
-        const encoder = new TextEncoder();
-        const messageBytes = encoder.encode(message);
-        const signature = await ed25519.signAsync(messageBytes, privateKey);
-        return bytesToBase64(signature);
-    }
-    /**
-     * Claims a username
-     * Generates a new keypair if one is not provided
-     */
-    async claimUsername(username, existingKeypair) {
-        // Generate or use existing keypair
-        const keypair = existingKeypair || await this.generateKeypair();
-        // Create signed message
-        const timestamp = Date.now();
-        const message = `claim:${username}:${timestamp}`;
-        const signature = await this.signMessage(message, keypair.privateKey);
-        // Send claim request
-        const response = await fetch(`${this.baseUrl}/usernames/claim`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                username,
-                publicKey: keypair.publicKey,
-                signature,
-                message
-            })
-        });
-        if (!response.ok) {
-            const error = await response.json();
-            throw new Error(error.error || 'Failed to claim username');
-        }
-        const data = await response.json();
-        return {
-            username: data.username,
-            publicKey: keypair.publicKey,
-            privateKey: keypair.privateKey,
-            claimedAt: data.claimedAt,
-            expiresAt: data.expiresAt
-        };
-    }
-    /**
-     * Checks if a username is available
-     */
-    async checkUsername(username) {
-        const response = await fetch(`${this.baseUrl}/usernames/${username}`);
-        if (!response.ok) {
-            throw new Error('Failed to check username');
-        }
-        const data = await response.json();
-        return {
-            username: data.username,
-            available: data.available,
-            claimedAt: data.claimedAt,
-            expiresAt: data.expiresAt,
-            publicKey: data.publicKey
-        };
-    }
-    /**
-     * Helper: Save keypair to localStorage
-     * WARNING: This stores the private key in localStorage which is not the most secure
-     * For production use, consider using IndexedDB with encryption or hardware security modules
-     */
-    saveKeypairToStorage(username, publicKey, privateKey) {
-        const data = { username, publicKey, privateKey, savedAt: Date.now() };
-        localStorage.setItem(`rondevu:keypair:${username}`, JSON.stringify(data));
-    }
-    /**
-     * Helper: Load keypair from localStorage
-     */
-    loadKeypairFromStorage(username) {
-        const stored = localStorage.getItem(`rondevu:keypair:${username}`);
-        if (!stored)
-            return null;
-        try {
-            const data = JSON.parse(stored);
-            return { publicKey: data.publicKey, privateKey: data.privateKey };
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Helper: Delete keypair from localStorage
-     */
-    deleteKeypairFromStorage(username) {
-        localStorage.removeItem(`rondevu:keypair:${username}`);
-    }
-    /**
-     * Export keypair as JSON string (for backup)
-     */
-    exportKeypair(publicKey, privateKey) {
-        return JSON.stringify({
-            publicKey,
-            privateKey,
-            exportedAt: Date.now()
-        });
-    }
-    /**
-     * Import keypair from JSON string
-     */
-    importKeypair(json) {
-        const data = JSON.parse(json);
-        if (!data.publicKey || !data.privateKey) {
-            throw new Error('Invalid keypair format');
-        }
-        return { publicKey: data.publicKey, privateKey: data.privateKey };
-    }
-}