@xtr-dev/rondevu-client 0.12.4 → 0.17.0

package/dist/rondevu-service.d.ts

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

package/dist/rondevu-service.js

@@ -1,170 +0,0 @@
-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',
- *   offers: [{ 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);
-        console.log('[RondevuService] Constructor called:', {
-            username: this.username,
-            hasKeypair: !!this.keypair,
-            publicKey: this.keypair?.publicKey
-        });
-    }
-    /**
-     * Initialize the service - generates keypair if not provided
-     * Call this before using other methods
-     */
-    async initialize() {
-        console.log('[RondevuService] Initialize called, hasKeypair:', !!this.keypair);
-        if (!this.keypair) {
-            console.log('[RondevuService] Generating new keypair...');
-            this.keypair = await RondevuAPI.generateKeypair();
-            console.log('[RondevuService] Generated keypair, publicKey:', this.keypair.publicKey);
-        }
-        else {
-            console.log('[RondevuService] Using existing keypair, publicKey:', this.keypair.publicKey);
-        }
-        // Register with API if no credentials provided
-        if (!this.api['credentials']) {
-            const credentials = await this.api.register();
-            this.api.setCredentials(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.publicKey === 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:${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, offers, 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,
-            offers,
-            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 username
-     */
-    getUsername() {
-        return this.username;
-    }
-    /**
-     * Get the public key
-     */
-    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
-     */
-    getAPI() {
-        return this.api;
-    }
-}

package/dist/service-client.d.ts

@@ -1,77 +0,0 @@
-import { RondevuService } from './rondevu-service.js';
-import { RTCDurableConnection } from './durable-connection.js';
-import { EventBus } from './event-bus.js';
-export interface ServiceClientOptions {
-    username: string;
-    serviceFqn: string;
-    rondevuService: RondevuService;
-    autoReconnect?: boolean;
-    maxReconnectAttempts?: number;
-    rtcConfiguration?: RTCConfiguration;
-}
-export interface ServiceClientEvents {
-    connected: RTCDurableConnection;
-    disconnected: void;
-    reconnecting: {
-        attempt: number;
-        maxAttempts: number;
-    };
-    error: Error;
-}
-/**
- * ServiceClient - High-level wrapper for connecting to a WebRTC service
- *
- * Simplifies client connection by handling:
- * - Service discovery
- * - Offer/answer exchange
- * - ICE candidate polling
- * - Automatic reconnection
- *
- * @example
- * ```typescript
- * const client = new ServiceClient({
- *     username: 'host-user',
- *     serviceFqn: 'chat.app@1.0.0',
- *     rondevuService: myService
- * })
- *
- * client.events.on('connected', conn => {
- *     conn.events.on('message', msg => console.log('Received:', msg))
- *     conn.sendMessage('Hello from client!')
- * })
- *
- * await client.connect()
- * ```
- */
-export declare class ServiceClient {
-    private options;
-    events: EventBus<ServiceClientEvents>;
-    private signaler;
-    private webrtcContext;
-    private connection;
-    private autoReconnect;
-    private maxReconnectAttempts;
-    private reconnectAttempts;
-    private isConnecting;
-    constructor(options: ServiceClientOptions);
-    /**
-     * Connect to the service
-     */
-    connect(): Promise<RTCDurableConnection>;
-    /**
-     * Disconnect from the service
-     */
-    dispose(): void;
-    /**
-     * @deprecated Use dispose() instead
-     */
-    disconnect(): void;
-    /**
-     * Attempt to reconnect
-     */
-    private attemptReconnect;
-    /**
-     * Get the current connection
-     */
-    getConnection(): RTCDurableConnection | null;
-}

package/dist/service-client.js

@@ -1,158 +0,0 @@
-import { RondevuSignaler } from './rondevu-signaler.js';
-import { WebRTCContext } from './webrtc-context.js';
-import { RTCDurableConnection } from './durable-connection.js';
-import { EventBus } from './event-bus.js';
-/**
- * ServiceClient - High-level wrapper for connecting to a WebRTC service
- *
- * Simplifies client connection by handling:
- * - Service discovery
- * - Offer/answer exchange
- * - ICE candidate polling
- * - Automatic reconnection
- *
- * @example
- * ```typescript
- * const client = new ServiceClient({
- *     username: 'host-user',
- *     serviceFqn: 'chat.app@1.0.0',
- *     rondevuService: myService
- * })
- *
- * client.events.on('connected', conn => {
- *     conn.events.on('message', msg => console.log('Received:', msg))
- *     conn.sendMessage('Hello from client!')
- * })
- *
- * await client.connect()
- * ```
- */
-export class ServiceClient {
-    constructor(options) {
-        this.options = options;
-        this.signaler = null;
-        this.connection = null;
-        this.reconnectAttempts = 0;
-        this.isConnecting = false;
-        this.events = new EventBus();
-        this.webrtcContext = new WebRTCContext(options.rtcConfiguration);
-        this.autoReconnect = options.autoReconnect !== undefined ? options.autoReconnect : true;
-        this.maxReconnectAttempts = options.maxReconnectAttempts || 5;
-    }
-    /**
-     * Connect to the service
-     */
-    async connect() {
-        if (this.isConnecting) {
-            throw new Error('Connection already in progress');
-        }
-        if (this.connection) {
-            throw new Error('Already connected. Disconnect first.');
-        }
-        this.isConnecting = true;
-        try {
-            // Create signaler
-            this.signaler = new RondevuSignaler(this.options.rondevuService, this.options.serviceFqn, this.options.username);
-            // Wait for remote offer from signaler
-            const remoteOffer = await new Promise((resolve, reject) => {
-                const timeout = setTimeout(() => {
-                    reject(new Error('Service discovery timeout'));
-                }, 30000);
-                this.signaler.addOfferListener((offer) => {
-                    clearTimeout(timeout);
-                    resolve(offer);
-                });
-            });
-            // Create connection with remote offer (makes us the answerer)
-            const connection = new RTCDurableConnection({
-                context: this.webrtcContext,
-                signaler: this.signaler,
-                offer: remoteOffer
-            });
-            // Wait for connection to be ready
-            await connection.ready;
-            // Set up connection event listeners
-            connection.events.on('state-change', (state) => {
-                if (state === 'connected') {
-                    this.reconnectAttempts = 0;
-                    this.events.emit('connected', connection);
-                }
-                else if (state === 'disconnected') {
-                    this.events.emit('disconnected', undefined);
-                    if (this.autoReconnect && this.reconnectAttempts < this.maxReconnectAttempts) {
-                        this.attemptReconnect();
-                    }
-                }
-            });
-            this.connection = connection;
-            this.isConnecting = false;
-            return connection;
-        }
-        catch (err) {
-            this.isConnecting = false;
-            const error = err instanceof Error ? err : new Error(String(err));
-            this.events.emit('error', error);
-            throw error;
-        }
-    }
-    /**
-     * Disconnect from the service
-     */
-    dispose() {
-        if (this.signaler) {
-            this.signaler.dispose();
-            this.signaler = null;
-        }
-        if (this.connection) {
-            this.connection.disconnect();
-            this.connection = null;
-        }
-        this.isConnecting = false;
-        this.reconnectAttempts = 0;
-    }
-    /**
-     * @deprecated Use dispose() instead
-     */
-    disconnect() {
-        this.dispose();
-    }
-    /**
-     * Attempt to reconnect
-     */
-    async attemptReconnect() {
-        this.reconnectAttempts++;
-        this.events.emit('reconnecting', {
-            attempt: this.reconnectAttempts,
-            maxAttempts: this.maxReconnectAttempts
-        });
-        // Cleanup old connection
-        if (this.signaler) {
-            this.signaler.dispose();
-            this.signaler = null;
-        }
-        if (this.connection) {
-            this.connection = null;
-        }
-        // Wait a bit before reconnecting
-        await new Promise(resolve => setTimeout(resolve, 1000 * this.reconnectAttempts));
-        try {
-            await this.connect();
-        }
-        catch (err) {
-            console.error('Reconnection attempt failed:', err);
-            if (this.reconnectAttempts < this.maxReconnectAttempts) {
-                this.attemptReconnect();
-            }
-            else {
-                const error = new Error('Max reconnection attempts reached');
-                this.events.emit('error', error);
-            }
-        }
-    }
-    /**
-     * Get the current connection
-     */
-    getConnection() {
-        return this.connection;
-    }
-}

package/dist/service-host.d.ts

@@ -1,67 +0,0 @@
-import { RondevuService } from './rondevu-service.js';
-import { RTCDurableConnection } from './durable-connection.js';
-import { EventBus } from './event-bus.js';
-export interface ServiceHostOptions {
-    service: string;
-    rondevuService: RondevuService;
-    maxPeers?: number;
-    ttl?: number;
-    isPublic?: boolean;
-    rtcConfiguration?: RTCConfiguration;
-    metadata?: Record<string, any>;
-}
-export interface ServiceHostEvents {
-    connection: RTCDurableConnection;
-    error: Error;
-}
-/**
- * ServiceHost - High-level wrapper for hosting a WebRTC service
- *
- * Simplifies hosting by handling:
- * - Offer/answer exchange
- * - ICE candidate polling
- * - Connection pool management
- * - Automatic reconnection
- *
- * @example
- * ```typescript
- * const host = new ServiceHost({
- *     service: 'chat.app@1.0.0',
- *     rondevuService: myService,
- *     maxPeers: 5
- * })
- *
- * host.events.on('connection', conn => {
- *     conn.events.on('message', msg => console.log('Received:', msg))
- *     conn.sendMessage('Hello!')
- * })
- *
- * await host.start()
- * ```
- */
-export declare class ServiceHost {
-    private options;
-    events: EventBus<ServiceHostEvents>;
-    private signaler;
-    private webrtcContext;
-    private connections;
-    private maxPeers;
-    private running;
-    constructor(options: ServiceHostOptions);
-    /**
-     * Start hosting the service
-     */
-    start(): Promise<void>;
-    /**
-     * Create the next connection for incoming peers
-     */
-    private createNextConnection;
-    /**
-     * Stop hosting the service
-     */
-    dispose(): void;
-    /**
-     * Get all active connections
-     */
-    getConnections(): RTCDurableConnection[];
-}

package/dist/service-host.js

@@ -1,120 +0,0 @@
-import { RondevuSignaler } from './rondevu-signaler.js';
-import { WebRTCContext } from './webrtc-context.js';
-import { RTCDurableConnection } from './durable-connection.js';
-import { EventBus } from './event-bus.js';
-/**
- * ServiceHost - High-level wrapper for hosting a WebRTC service
- *
- * Simplifies hosting by handling:
- * - Offer/answer exchange
- * - ICE candidate polling
- * - Connection pool management
- * - Automatic reconnection
- *
- * @example
- * ```typescript
- * const host = new ServiceHost({
- *     service: 'chat.app@1.0.0',
- *     rondevuService: myService,
- *     maxPeers: 5
- * })
- *
- * host.events.on('connection', conn => {
- *     conn.events.on('message', msg => console.log('Received:', msg))
- *     conn.sendMessage('Hello!')
- * })
- *
- * await host.start()
- * ```
- */
-export class ServiceHost {
-    constructor(options) {
-        this.options = options;
-        this.signaler = null;
-        this.connections = [];
-        this.running = false;
-        this.events = new EventBus();
-        this.webrtcContext = new WebRTCContext(options.rtcConfiguration);
-        this.maxPeers = options.maxPeers || 5;
-    }
-    /**
-     * Start hosting the service
-     */
-    async start() {
-        if (this.running) {
-            throw new Error('ServiceHost already running');
-        }
-        this.running = true;
-        // Create signaler
-        this.signaler = new RondevuSignaler(this.options.rondevuService, this.options.service);
-        // Create first connection (offerer)
-        const connection = new RTCDurableConnection({
-            context: this.webrtcContext,
-            signaler: this.signaler,
-            offer: null // null means we're the offerer
-        });
-        // Wait for connection to be ready
-        await connection.ready;
-        // Set up connection event listeners
-        connection.events.on('state-change', (state) => {
-            if (state === 'connected') {
-                this.connections.push(connection);
-                this.events.emit('connection', connection);
-                // Create next connection if under maxPeers
-                if (this.connections.length < this.maxPeers) {
-                    this.createNextConnection().catch(err => {
-                        console.error('Failed to create next connection:', err);
-                        this.events.emit('error', err);
-                    });
-                }
-            }
-            else if (state === 'disconnected') {
-                // Remove from connections list
-                const index = this.connections.indexOf(connection);
-                if (index > -1) {
-                    this.connections.splice(index, 1);
-                }
-            }
-        });
-        // Publish service with the offer
-        const offer = connection.connection?.localDescription;
-        if (!offer?.sdp) {
-            throw new Error('Offer SDP is empty');
-        }
-        await this.signaler.setOffer(offer);
-    }
-    /**
-     * Create the next connection for incoming peers
-     */
-    async createNextConnection() {
-        if (!this.signaler || !this.running) {
-            return;
-        }
-        // For now, we'll use the same offer for all connections
-        // In a production scenario, you'd create multiple offers
-        // This is a limitation of the current service model
-        // which publishes one offer per service
-    }
-    /**
-     * Stop hosting the service
-     */
-    dispose() {
-        this.running = false;
-        // Cleanup signaler
-        if (this.signaler) {
-            this.signaler.dispose();
-            this.signaler = null;
-        }
-        // Disconnect all connections
-        for (const conn of this.connections) {
-            conn.disconnect();
-        }
-        this.connections = [];
-    }
-    /**
-     * Get all active connections
-     */
-    getConnections() {
-        return [...this.connections];
-    }
-}

package/dist/signaler.d.ts

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