@xtr-dev/rondevu-client 0.18.10 → 0.21.1

package/dist/api.d.ts

@@ -1,146 +0,0 @@
-/**
- * Rondevu API Client - RPC interface
- */
-import { CryptoAdapter, Keypair } from './crypto-adapter.js';
-import { BatcherOptions } from './rpc-batcher.js';
-export type { Keypair } from './crypto-adapter.js';
-export type { BatcherOptions } from './rpc-batcher.js';
-export interface OfferRequest {
-    sdp: string;
-}
-export interface ServiceRequest {
-    serviceFqn: string;
-    offers: OfferRequest[];
-    ttl?: number;
-    signature: string;
-    message: string;
-}
-export interface ServiceOffer {
-    offerId: string;
-    sdp: string;
-    createdAt: number;
-    expiresAt: number;
-}
-export interface Service {
-    serviceId: string;
-    offers: ServiceOffer[];
-    username: string;
-    serviceFqn: string;
-    createdAt: number;
-    expiresAt: number;
-}
-export interface IceCandidate {
-    candidate: RTCIceCandidateInit | null;
-    role: 'offerer' | 'answerer';
-    createdAt: number;
-}
-/**
- * RondevuAPI - RPC-based API client for Rondevu signaling server
- */
-export declare class RondevuAPI {
-    private baseUrl;
-    private username;
-    private keypair;
-    private crypto;
-    private batcher;
-    constructor(baseUrl: string, username: string, keypair: Keypair, cryptoAdapter?: CryptoAdapter, batcherOptions?: BatcherOptions | false);
-    /**
-     * Generate authentication parameters for RPC calls
-     */
-    private generateAuth;
-    /**
-     * Execute RPC call with optional batching
-     */
-    private rpc;
-    /**
-     * Execute single RPC call directly (bypasses batcher)
-     */
-    private rpcDirect;
-    /**
-     * Execute batch RPC calls directly (bypasses batcher)
-     */
-    private rpcBatchDirect;
-    /**
-     * Generate an Ed25519 keypair for username claiming and service publishing
-     * @param cryptoAdapter - Optional crypto adapter (defaults to WebCryptoAdapter)
-     */
-    static generateKeypair(cryptoAdapter?: CryptoAdapter): Promise<Keypair>;
-    /**
-     * Sign a message with an Ed25519 private key
-     * @param cryptoAdapter - Optional crypto adapter (defaults to WebCryptoAdapter)
-     */
-    static signMessage(message: string, privateKeyBase64: string, cryptoAdapter?: CryptoAdapter): Promise<string>;
-    /**
-     * Verify an Ed25519 signature
-     * @param cryptoAdapter - Optional crypto adapter (defaults to WebCryptoAdapter)
-     */
-    static verifySignature(message: string, signatureBase64: string, publicKeyBase64: string, cryptoAdapter?: CryptoAdapter): Promise<boolean>;
-    /**
-     * Check if a username is available
-     */
-    isUsernameAvailable(username: string): Promise<boolean>;
-    /**
-     * Check if current username is claimed
-     */
-    isUsernameClaimed(): Promise<boolean>;
-    /**
-     * Publish a service
-     */
-    publishService(service: ServiceRequest): Promise<Service>;
-    /**
-     * Get service by FQN (direct lookup, random, or paginated)
-     */
-    getService(serviceFqn: string, options?: {
-        limit?: number;
-        offset?: number;
-    }): Promise<any>;
-    /**
-     * Delete a service
-     */
-    deleteService(serviceFqn: string): Promise<void>;
-    /**
-     * Answer an offer
-     */
-    answerOffer(serviceFqn: string, offerId: string, sdp: string): Promise<void>;
-    /**
-     * Get answer for a specific offer (offerer polls this)
-     */
-    getOfferAnswer(serviceFqn: string, offerId: string): Promise<{
-        sdp: string;
-        offerId: string;
-        answererId: string;
-        answeredAt: number;
-    } | null>;
-    /**
-     * Combined polling for answers and ICE candidates
-     */
-    poll(since?: number): Promise<{
-        answers: Array<{
-            offerId: string;
-            serviceId?: string;
-            answererId: string;
-            sdp: string;
-            answeredAt: number;
-        }>;
-        iceCandidates: Record<string, Array<{
-            candidate: RTCIceCandidateInit | null;
-            role: 'offerer' | 'answerer';
-            peerId: string;
-            createdAt: number;
-        }>>;
-    }>;
-    /**
-     * Add ICE candidates to a specific offer
-     */
-    addOfferIceCandidates(serviceFqn: string, offerId: string, candidates: RTCIceCandidateInit[]): Promise<{
-        count: number;
-        offerId: string;
-    }>;
-    /**
-     * Get ICE candidates for a specific offer
-     */
-    getOfferIceCandidates(serviceFqn: string, offerId: string, since?: number): Promise<{
-        candidates: IceCandidate[];
-        offerId: string;
-    }>;
-}

package/dist/api.js

@@ -1,279 +0,0 @@
-/**
- * Rondevu API Client - RPC interface
- */
-import { WebCryptoAdapter } from './web-crypto-adapter.js';
-import { RpcBatcher } from './rpc-batcher.js';
-/**
- * RondevuAPI - RPC-based API client for Rondevu signaling server
- */
-export class RondevuAPI {
-    constructor(baseUrl, username, keypair, cryptoAdapter, batcherOptions) {
-        this.baseUrl = baseUrl;
-        this.username = username;
-        this.keypair = keypair;
-        this.batcher = null;
-        // Use WebCryptoAdapter by default (browser environment)
-        this.crypto = cryptoAdapter || new WebCryptoAdapter();
-        // Create batcher if not explicitly disabled
-        if (batcherOptions !== false) {
-            this.batcher = new RpcBatcher((requests) => this.rpcBatchDirect(requests), batcherOptions);
-        }
-    }
-    /**
-     * Generate authentication parameters for RPC calls
-     */
-    async generateAuth(method, params = '') {
-        const timestamp = Date.now();
-        const message = params
-            ? `${method}:${this.username}:${params}:${timestamp}`
-            : `${method}:${this.username}:${timestamp}`;
-        const signature = await this.crypto.signMessage(message, this.keypair.privateKey);
-        return { message, signature };
-    }
-    /**
-     * Execute RPC call with optional batching
-     */
-    async rpc(request) {
-        // Use batcher if enabled
-        if (this.batcher) {
-            return await this.batcher.add(request);
-        }
-        // Direct call without batching
-        return await this.rpcDirect(request);
-    }
-    /**
-     * Execute single RPC call directly (bypasses batcher)
-     */
-    async rpcDirect(request) {
-        const response = await fetch(`${this.baseUrl}/rpc`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(request),
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-        const result = await response.json();
-        if (!result.success) {
-            throw new Error(result.error || 'RPC call failed');
-        }
-        return result.result;
-    }
-    /**
-     * Execute batch RPC calls directly (bypasses batcher)
-     */
-    async rpcBatchDirect(requests) {
-        const response = await fetch(`${this.baseUrl}/rpc`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(requests),
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-        const results = await response.json();
-        // Validate response is an array
-        if (!Array.isArray(results)) {
-            console.error('Invalid RPC batch response:', results);
-            throw new Error('Server returned invalid batch response (not an array)');
-        }
-        // Check response length matches request length
-        if (results.length !== requests.length) {
-            console.error(`Response length mismatch: expected ${requests.length}, got ${results.length}`);
-        }
-        return results.map((result, i) => {
-            if (!result || typeof result !== 'object') {
-                throw new Error(`Invalid response at index ${i}`);
-            }
-            if (!result.success) {
-                throw new Error(result.error || `RPC call ${i} failed`);
-            }
-            return result.result;
-        });
-    }
-    // ============================================
-    // Ed25519 Cryptography Helpers
-    // ============================================
-    /**
-     * Generate an Ed25519 keypair for username claiming and service publishing
-     * @param cryptoAdapter - Optional crypto adapter (defaults to WebCryptoAdapter)
-     */
-    static async generateKeypair(cryptoAdapter) {
-        const adapter = cryptoAdapter || new WebCryptoAdapter();
-        return await adapter.generateKeypair();
-    }
-    /**
-     * Sign a message with an Ed25519 private key
-     * @param cryptoAdapter - Optional crypto adapter (defaults to WebCryptoAdapter)
-     */
-    static async signMessage(message, privateKeyBase64, cryptoAdapter) {
-        const adapter = cryptoAdapter || new WebCryptoAdapter();
-        return await adapter.signMessage(message, privateKeyBase64);
-    }
-    /**
-     * Verify an Ed25519 signature
-     * @param cryptoAdapter - Optional crypto adapter (defaults to WebCryptoAdapter)
-     */
-    static async verifySignature(message, signatureBase64, publicKeyBase64, cryptoAdapter) {
-        const adapter = cryptoAdapter || new WebCryptoAdapter();
-        return await adapter.verifySignature(message, signatureBase64, publicKeyBase64);
-    }
-    // ============================================
-    // Username Management
-    // ============================================
-    /**
-     * Check if a username is available
-     */
-    async isUsernameAvailable(username) {
-        const auth = await this.generateAuth('getUser', username);
-        const result = await this.rpc({
-            method: 'getUser',
-            message: auth.message,
-            signature: auth.signature,
-            params: { username },
-        });
-        return result.available;
-    }
-    /**
-     * Check if current username is claimed
-     */
-    async isUsernameClaimed() {
-        const auth = await this.generateAuth('getUser', this.username);
-        const result = await this.rpc({
-            method: 'getUser',
-            message: auth.message,
-            signature: auth.signature,
-            params: { username: this.username },
-        });
-        return !result.available;
-    }
-    // ============================================
-    // Service Management
-    // ============================================
-    /**
-     * Publish a service
-     */
-    async publishService(service) {
-        const auth = await this.generateAuth('publishService', service.serviceFqn);
-        return await this.rpc({
-            method: 'publishService',
-            message: auth.message,
-            signature: auth.signature,
-            publicKey: this.keypair.publicKey,
-            params: {
-                serviceFqn: service.serviceFqn,
-                offers: service.offers,
-                ttl: service.ttl,
-            },
-        });
-    }
-    /**
-     * Get service by FQN (direct lookup, random, or paginated)
-     */
-    async getService(serviceFqn, options) {
-        const auth = await this.generateAuth('getService', serviceFqn);
-        return await this.rpc({
-            method: 'getService',
-            message: auth.message,
-            signature: auth.signature,
-            publicKey: this.keypair.publicKey,
-            params: {
-                serviceFqn,
-                ...options,
-            },
-        });
-    }
-    /**
-     * Delete a service
-     */
-    async deleteService(serviceFqn) {
-        const auth = await this.generateAuth('deleteService', serviceFqn);
-        await this.rpc({
-            method: 'deleteService',
-            message: auth.message,
-            signature: auth.signature,
-            publicKey: this.keypair.publicKey,
-            params: { serviceFqn },
-        });
-    }
-    // ============================================
-    // WebRTC Signaling
-    // ============================================
-    /**
-     * Answer an offer
-     */
-    async answerOffer(serviceFqn, offerId, sdp) {
-        const auth = await this.generateAuth('answerOffer', offerId);
-        await this.rpc({
-            method: 'answerOffer',
-            message: auth.message,
-            signature: auth.signature,
-            publicKey: this.keypair.publicKey,
-            params: { serviceFqn, offerId, sdp },
-        });
-    }
-    /**
-     * Get answer for a specific offer (offerer polls this)
-     */
-    async getOfferAnswer(serviceFqn, offerId) {
-        try {
-            const auth = await this.generateAuth('getOfferAnswer', offerId);
-            return await this.rpc({
-                method: 'getOfferAnswer',
-                message: auth.message,
-                signature: auth.signature,
-                publicKey: this.keypair.publicKey,
-                params: { serviceFqn, offerId },
-            });
-        }
-        catch (err) {
-            if (err.message.includes('not yet answered')) {
-                return null;
-            }
-            throw err;
-        }
-    }
-    /**
-     * Combined polling for answers and ICE candidates
-     */
-    async poll(since) {
-        const auth = await this.generateAuth('poll');
-        return await this.rpc({
-            method: 'poll',
-            message: auth.message,
-            signature: auth.signature,
-            publicKey: this.keypair.publicKey,
-            params: { since },
-        });
-    }
-    /**
-     * Add ICE candidates to a specific offer
-     */
-    async addOfferIceCandidates(serviceFqn, offerId, candidates) {
-        const auth = await this.generateAuth('addIceCandidates', offerId);
-        return await this.rpc({
-            method: 'addIceCandidates',
-            message: auth.message,
-            signature: auth.signature,
-            publicKey: this.keypair.publicKey,
-            params: { serviceFqn, offerId, candidates },
-        });
-    }
-    /**
-     * Get ICE candidates for a specific offer
-     */
-    async getOfferIceCandidates(serviceFqn, offerId, since = 0) {
-        const auth = await this.generateAuth('getIceCandidates', `${offerId}:${since}`);
-        const result = await this.rpc({
-            method: 'getIceCandidates',
-            message: auth.message,
-            signature: auth.signature,
-            publicKey: this.keypair.publicKey,
-            params: { serviceFqn, offerId, since },
-        });
-        return {
-            candidates: result.candidates || [],
-            offerId: result.offerId,
-        };
-    }
-}

package/dist/connection-config.d.ts

@@ -1,21 +0,0 @@
-/**
- * Connection configuration interfaces and defaults
- */
-export interface ConnectionConfig {
-    connectionTimeout: number;
-    iceGatheringTimeout: number;
-    reconnectEnabled: boolean;
-    maxReconnectAttempts: number;
-    reconnectBackoffBase: number;
-    reconnectBackoffMax: number;
-    reconnectJitter: number;
-    bufferEnabled: boolean;
-    maxBufferSize: number;
-    maxBufferAge: number;
-    preserveBufferOnClose: boolean;
-    icePollingInterval: number;
-    icePollingTimeout: number;
-    debug: boolean;
-}
-export declare const DEFAULT_CONNECTION_CONFIG: ConnectionConfig;
-export declare function mergeConnectionConfig(userConfig?: Partial<ConnectionConfig>): ConnectionConfig;

package/dist/crypto-adapter.d.ts

@@ -1,37 +0,0 @@
-/**
- * Crypto adapter interface for platform-independent cryptographic operations
- */
-export interface Keypair {
-    publicKey: string;
-    privateKey: string;
-}
-/**
- * Platform-independent crypto adapter interface
- * Implementations provide platform-specific crypto operations
- */
-export interface CryptoAdapter {
-    /**
-     * Generate an Ed25519 keypair
-     */
-    generateKeypair(): Promise<Keypair>;
-    /**
-     * Sign a message with an Ed25519 private key
-     */
-    signMessage(message: string, privateKeyBase64: string): Promise<string>;
-    /**
-     * Verify an Ed25519 signature
-     */
-    verifySignature(message: string, signatureBase64: string, publicKeyBase64: string): Promise<boolean>;
-    /**
-     * Convert Uint8Array to base64 string
-     */
-    bytesToBase64(bytes: Uint8Array): string;
-    /**
-     * Convert base64 string to Uint8Array
-     */
-    base64ToBytes(base64: string): Uint8Array;
-    /**
-     * Generate random bytes
-     */
-    randomBytes(length: number): Uint8Array;
-}

package/dist/index.d.ts

@@ -1,13 +0,0 @@
-/**
- * @xtr-dev/rondevu-client
- * WebRTC peer signaling client
- */
-export { Rondevu, RondevuError, NetworkError, ValidationError, ConnectionError } from './rondevu.js';
-export { RondevuAPI } from './api.js';
-export { RpcBatcher } from './rpc-batcher.js';
-export { WebCryptoAdapter } from './web-crypto-adapter.js';
-export { NodeCryptoAdapter } from './node-crypto-adapter.js';
-export type { Signaler, Binnable, } from './types.js';
-export type { Keypair, OfferRequest, ServiceRequest, Service, ServiceOffer, IceCandidate, } from './api.js';
-export type { RondevuOptions, PublishServiceOptions, ConnectToServiceOptions, ConnectionContext, OfferContext, OfferFactory, ActiveOffer, FindServiceOptions, ServiceResult, PaginatedServiceResult } from './rondevu.js';
-export type { CryptoAdapter } from './crypto-adapter.js';

package/dist/index.js

@@ -1,10 +0,0 @@
-/**
- * @xtr-dev/rondevu-client
- * WebRTC peer signaling client
- */
-export { Rondevu, RondevuError, NetworkError, ValidationError, ConnectionError } from './rondevu.js';
-export { RondevuAPI } from './api.js';
-export { RpcBatcher } from './rpc-batcher.js';
-// Export crypto adapters
-export { WebCryptoAdapter } from './web-crypto-adapter.js';
-export { NodeCryptoAdapter } from './node-crypto-adapter.js';

package/dist/node-crypto-adapter.d.ts

@@ -1,35 +0,0 @@
-/**
- * Node.js Crypto adapter for Node.js environments
- * Requires Node.js 19+ or Node.js 18 with --experimental-global-webcrypto flag
- */
-import { CryptoAdapter, Keypair } from './crypto-adapter.js';
-/**
- * Node.js Crypto implementation using Node.js built-in APIs
- * Uses Buffer for base64 encoding and crypto.randomBytes for random generation
- *
- * Requirements:
- * - Node.js 19+ (crypto.subtle available globally)
- * - OR Node.js 18 with --experimental-global-webcrypto flag
- *
- * @example
- * ```typescript
- * import { RondevuAPI } from '@xtr-dev/rondevu-client'
- * import { NodeCryptoAdapter } from '@xtr-dev/rondevu-client/node'
- *
- * const api = new RondevuAPI(
- *   'https://signal.example.com',
- *   'alice',
- *   keypair,
- *   new NodeCryptoAdapter()
- * )
- * ```
- */
-export declare class NodeCryptoAdapter implements CryptoAdapter {
-    constructor();
-    generateKeypair(): Promise<Keypair>;
-    signMessage(message: string, privateKeyBase64: string): Promise<string>;
-    verifySignature(message: string, signatureBase64: string, publicKeyBase64: string): Promise<boolean>;
-    bytesToBase64(bytes: Uint8Array): string;
-    base64ToBytes(base64: string): Uint8Array;
-    randomBytes(length: number): Uint8Array;
-}

package/dist/node-crypto-adapter.js

@@ -1,78 +0,0 @@
-/**
- * Node.js Crypto adapter for Node.js environments
- * Requires Node.js 19+ or Node.js 18 with --experimental-global-webcrypto flag
- */
-import * as ed25519 from '@noble/ed25519';
-/**
- * Node.js Crypto implementation using Node.js built-in APIs
- * Uses Buffer for base64 encoding and crypto.randomBytes for random generation
- *
- * Requirements:
- * - Node.js 19+ (crypto.subtle available globally)
- * - OR Node.js 18 with --experimental-global-webcrypto flag
- *
- * @example
- * ```typescript
- * import { RondevuAPI } from '@xtr-dev/rondevu-client'
- * import { NodeCryptoAdapter } from '@xtr-dev/rondevu-client/node'
- *
- * const api = new RondevuAPI(
- *   'https://signal.example.com',
- *   'alice',
- *   keypair,
- *   new NodeCryptoAdapter()
- * )
- * ```
- */
-export class NodeCryptoAdapter {
-    constructor() {
-        // Set SHA-512 hash function for ed25519 using Node's crypto.subtle
-        if (typeof crypto === 'undefined' || !crypto.subtle) {
-            throw new Error('crypto.subtle is not available. ' +
-                'Node.js 19+ is required, or Node.js 18 with --experimental-global-webcrypto flag');
-        }
-        ed25519.hashes.sha512Async = async (message) => {
-            const hash = await crypto.subtle.digest('SHA-512', message);
-            return new Uint8Array(hash);
-        };
-    }
-    async generateKeypair() {
-        const privateKey = ed25519.utils.randomSecretKey();
-        const publicKey = await ed25519.getPublicKeyAsync(privateKey);
-        return {
-            publicKey: this.bytesToBase64(publicKey),
-            privateKey: this.bytesToBase64(privateKey),
-        };
-    }
-    async signMessage(message, privateKeyBase64) {
-        const privateKey = this.base64ToBytes(privateKeyBase64);
-        const encoder = new TextEncoder();
-        const messageBytes = encoder.encode(message);
-        const signature = await ed25519.signAsync(messageBytes, privateKey);
-        return this.bytesToBase64(signature);
-    }
-    async verifySignature(message, signatureBase64, publicKeyBase64) {
-        try {
-            const signature = this.base64ToBytes(signatureBase64);
-            const publicKey = this.base64ToBytes(publicKeyBase64);
-            const encoder = new TextEncoder();
-            const messageBytes = encoder.encode(message);
-            return await ed25519.verifyAsync(signature, messageBytes, publicKey);
-        }
-        catch {
-            return false;
-        }
-    }
-    bytesToBase64(bytes) {
-        // Node.js Buffer provides native base64 encoding
-        return Buffer.from(bytes).toString('base64');
-    }
-    base64ToBytes(base64) {
-        // Node.js Buffer provides native base64 decoding
-        return new Uint8Array(Buffer.from(base64, 'base64'));
-    }
-    randomBytes(length) {
-        // Use Web Crypto API's getRandomValues (available in Node 19+)
-        return crypto.getRandomValues(new Uint8Array(length));
-    }
-}

package/dist/offerer-connection.d.ts

@@ -1,54 +0,0 @@
-/**
- * Offerer-side WebRTC connection with offer creation and answer processing
- */
-import { RondevuConnection } from './connection.js';
-import { RondevuAPI } from './api.js';
-import { ConnectionConfig } from './connection-config.js';
-export interface OffererOptions {
-    api: RondevuAPI;
-    serviceFqn: string;
-    offerId: string;
-    pc: RTCPeerConnection;
-    dc?: RTCDataChannel;
-    config?: Partial<ConnectionConfig>;
-}
-/**
- * Offerer connection - manages already-created offers and waits for answers
- */
-export declare class OffererConnection extends RondevuConnection {
-    private api;
-    private serviceFqn;
-    private offerId;
-    constructor(options: OffererOptions);
-    /**
-     * Initialize the connection - setup handlers for already-created offer
-     */
-    initialize(): Promise<void>;
-    /**
-     * Process an answer from the answerer
-     */
-    processAnswer(sdp: string, answererId: string): Promise<void>;
-    /**
-     * Generate a hash fingerprint of SDP for deduplication
-     */
-    private hashSdp;
-    /**
-     * Handle local ICE candidate generation
-     */
-    protected onLocalIceCandidate(candidate: RTCIceCandidate): void;
-    /**
-     * Poll for remote ICE candidates
-     */
-    protected pollIceCandidates(): void;
-    /**
-     * Attempt to reconnect
-     *
-     * Note: For offerer connections, reconnection is handled by the Rondevu instance
-     * creating a new offer via fillOffers(). This method is a no-op.
-     */
-    protected attemptReconnect(): void;
-    /**
-     * Get the offer ID
-     */
-    getOfferId(): string;
-}