@xtr-dev/rondevu-client 0.8.3 → 0.9.2

package/dist/services.d.ts

@@ -1,79 +0,0 @@
-import RondevuPeer from './peer/index.js';
-import { PooledServiceHandle, PoolStatus } from './service-pool.js';
-/**
- * Service publish result
- */
-export interface ServicePublishResult {
-    serviceId: string;
-    uuid: string;
-    offerId: string;
-    expiresAt: number;
-}
-/**
- * Service publish options
- */
-export interface PublishServiceOptions {
-    username: string;
-    privateKey: string;
-    serviceFqn: string;
-    rtcConfig?: RTCConfiguration;
-    isPublic?: boolean;
-    metadata?: Record<string, any>;
-    ttl?: number;
-    onConnection?: (peer: RondevuPeer) => void;
-}
-/**
- * Service handle for managing an exposed service
- */
-export interface ServiceHandle {
-    serviceId: string;
-    uuid: string;
-    offerId: string;
-    unpublish: () => Promise<void>;
-}
-/**
- * Rondevu Services API
- * Handles service publishing and management
- */
-export declare class RondevuServices {
-    private baseUrl;
-    private credentials;
-    private usernameApi;
-    private offersApi;
-    constructor(baseUrl: string, credentials: {
-        peerId: string;
-        secret: string;
-    });
-    /**
-     * Publishes a service
-     */
-    publishService(options: PublishServiceOptions): Promise<ServicePublishResult>;
-    /**
-     * Unpublishes a service
-     */
-    unpublishService(serviceId: string, username: string): Promise<void>;
-    /**
-     * Exposes a service with an automatic connection handler
-     * This is a convenience method that publishes the service and manages connections
-     *
-     * Set poolSize > 1 to enable offer pooling for handling multiple concurrent connections
-     */
-    exposeService(options: Omit<PublishServiceOptions, 'onConnection'> & {
-        handler: (channel: RTCDataChannel, peer: RondevuPeer, connectionId?: string) => void;
-        poolSize?: number;
-        pollingInterval?: number;
-        onPoolStatus?: (status: PoolStatus) => void;
-        onError?: (error: Error, context: string) => void;
-    }): Promise<ServiceHandle | PooledServiceHandle>;
-    /**
-     * Validates service FQN format
-     */
-    private validateServiceFqn;
-    /**
-     * Parses a service FQN into name and version
-     */
-    parseServiceFqn(fqn: string): {
-        name: string;
-        version: string;
-    };
-}

package/dist/services.js

@@ -1,206 +0,0 @@
-import { RondevuUsername } from './usernames.js';
-import RondevuPeer from './peer/index.js';
-import { RondevuOffers } from './offers.js';
-import { ServicePool } from './service-pool.js';
-/**
- * Rondevu Services API
- * Handles service publishing and management
- */
-export class RondevuServices {
-    constructor(baseUrl, credentials) {
-        this.baseUrl = baseUrl;
-        this.credentials = credentials;
-        this.usernameApi = new RondevuUsername(baseUrl);
-        this.offersApi = new RondevuOffers(baseUrl, credentials);
-    }
-    /**
-     * Publishes a service
-     */
-    async publishService(options) {
-        const { username, privateKey, serviceFqn, rtcConfig, isPublic = false, metadata, ttl } = options;
-        // Validate FQN format
-        this.validateServiceFqn(serviceFqn);
-        // Create WebRTC peer connection to generate offer
-        const pc = new RTCPeerConnection(rtcConfig || {
-            iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
-        });
-        // Add a data channel (required for datachannel-based services)
-        pc.createDataChannel('rondevu-service');
-        // Create offer
-        const offer = await pc.createOffer();
-        await pc.setLocalDescription(offer);
-        if (!offer.sdp) {
-            throw new Error('Failed to generate SDP');
-        }
-        // Create signature for username verification
-        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: offer.sdp,
-                ttl,
-                isPublic,
-                metadata,
-                signature,
-                message
-            })
-        });
-        if (!response.ok) {
-            const error = await response.json();
-            pc.close();
-            throw new Error(error.error || 'Failed to publish service');
-        }
-        const data = await response.json();
-        // Close the connection for now (would be kept open in a real implementation)
-        pc.close();
-        return {
-            serviceId: data.serviceId,
-            uuid: data.uuid,
-            offerId: data.offerId,
-            expiresAt: data.expiresAt
-        };
-    }
-    /**
-     * Unpublishes a service
-     */
-    async unpublishService(serviceId, username) {
-        const response = await fetch(`${this.baseUrl}/services/${serviceId}`, {
-            method: 'DELETE',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${this.credentials.peerId}:${this.credentials.secret}`
-            },
-            body: JSON.stringify({ username })
-        });
-        if (!response.ok) {
-            const error = await response.json();
-            throw new Error(error.error || 'Failed to unpublish service');
-        }
-    }
-    /**
-     * Exposes a service with an automatic connection handler
-     * This is a convenience method that publishes the service and manages connections
-     *
-     * Set poolSize > 1 to enable offer pooling for handling multiple concurrent connections
-     */
-    async exposeService(options) {
-        const { username, privateKey, serviceFqn, rtcConfig, isPublic, metadata, ttl, handler, poolSize, pollingInterval, onPoolStatus, onError } = options;
-        // If poolSize > 1, use pooled implementation
-        if (poolSize && poolSize > 1) {
-            const pool = new ServicePool(this.baseUrl, this.credentials, {
-                username,
-                privateKey,
-                serviceFqn,
-                rtcConfig,
-                isPublic,
-                metadata,
-                ttl,
-                handler: (channel, peer, connectionId) => handler(channel, peer, connectionId),
-                poolSize,
-                pollingInterval,
-                onPoolStatus,
-                onError
-            });
-            return await pool.start();
-        }
-        // Otherwise, use existing single-offer logic (UNCHANGED)
-        // Validate FQN
-        this.validateServiceFqn(serviceFqn);
-        // Create peer connection
-        const pc = new RTCPeerConnection(rtcConfig || {
-            iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
-        });
-        // Create data channel
-        const channel = pc.createDataChannel('rondevu-service');
-        // Set up handler
-        channel.onopen = () => {
-            const peer = new RondevuPeer(this.offersApi, rtcConfig || {
-                iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
-            });
-            handler(channel, peer);
-        };
-        // Create offer
-        const offer = await pc.createOffer();
-        await pc.setLocalDescription(offer);
-        if (!offer.sdp) {
-            pc.close();
-            throw new Error('Failed to generate 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: offer.sdp,
-                ttl,
-                isPublic,
-                metadata,
-                signature,
-                message
-            })
-        });
-        if (!response.ok) {
-            const error = await response.json();
-            pc.close();
-            throw new Error(error.error || 'Failed to expose service');
-        }
-        const data = await response.json();
-        return {
-            serviceId: data.serviceId,
-            uuid: data.uuid,
-            offerId: data.offerId,
-            unpublish: () => this.unpublishService(data.serviceId, username)
-        };
-    }
-    /**
-     * Validates service FQN format
-     */
-    validateServiceFqn(fqn) {
-        const parts = fqn.split('@');
-        if (parts.length !== 2) {
-            throw new Error('Service FQN must be in format: service-name@version');
-        }
-        const [serviceName, version] = parts;
-        // Validate service name (reverse domain notation)
-        const serviceNameRegex = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+$/;
-        if (!serviceNameRegex.test(serviceName)) {
-            throw new Error('Service name must be reverse domain notation (e.g., com.example.service)');
-        }
-        if (serviceName.length < 3 || serviceName.length > 128) {
-            throw new Error('Service name must be 3-128 characters');
-        }
-        // Validate version (semantic versioning)
-        const versionRegex = /^[0-9]+\.[0-9]+\.[0-9]+(-[a-z0-9.-]+)?$/;
-        if (!versionRegex.test(version)) {
-            throw new Error('Version must be semantic versioning (e.g., 1.0.0, 2.1.3-beta)');
-        }
-    }
-    /**
-     * Parses a service FQN into name and version
-     */
-    parseServiceFqn(fqn) {
-        const parts = fqn.split('@');
-        if (parts.length !== 2) {
-            throw new Error('Invalid FQN format');
-        }
-        return { name: parts[0], version: parts[1] };
-    }
-}

package/dist/types.d.ts

@@ -1,157 +0,0 @@
-/**
- * Session side - identifies which peer in a connection
- */
-export type Side = 'offerer' | 'answerer';
-/**
- * Request body for POST /offer
- */
-export interface CreateOfferRequest {
-    /** Peer identifier/metadata (max 1024 characters) */
-    peerId: string;
-    /** Signaling data for peer connection */
-    offer: string;
-    /** Optional custom connection code (if not provided, server generates UUID) */
-    code?: string;
-}
-/**
- * Response from POST /offer
- */
-export interface CreateOfferResponse {
-    /** Unique session identifier (UUID) */
-    code: string;
-}
-/**
- * Request body for POST /answer
- */
-export interface AnswerRequest {
-    /** Session UUID from the offer */
-    code: string;
-    /** Response signaling data (required if candidate not provided) */
-    answer?: string;
-    /** Additional signaling data (required if answer not provided) */
-    candidate?: string;
-    /** Which peer is sending the data */
-    side: Side;
-}
-/**
- * Response from POST /answer
- */
-export interface AnswerResponse {
-    success: boolean;
-}
-/**
- * Request body for POST /poll
- */
-export interface PollRequest {
-    /** Session UUID */
-    code: string;
-    /** Which side is polling */
-    side: Side;
-}
-/**
- * Response from POST /poll when side=offerer
- */
-export interface PollOffererResponse {
-    /** Answer from answerer (null if not yet received) */
-    answer: string | null;
-    /** Additional signaling data from answerer */
-    answerCandidates: string[];
-}
-/**
- * Response from POST /poll when side=answerer
- */
-export interface PollAnswererResponse {
-    /** Offer from offerer */
-    offer: string;
-    /** Additional signaling data from offerer */
-    offerCandidates: string[];
-}
-/**
- * Response from POST /poll (union type)
- */
-export type PollResponse = PollOffererResponse | PollAnswererResponse;
-/**
- * Response from GET / - server version information
- */
-export interface VersionResponse {
-    /** Git commit hash or version identifier */
-    version: string;
-}
-/**
- * Response from GET /health
- */
-export interface HealthResponse {
-    status: 'ok';
-    timestamp: number;
-    version: string;
-}
-/**
- * Error response structure
- */
-export interface ErrorResponse {
-    error: string;
-}
-/**
- * Client configuration options
- */
-export interface RondevuClientOptions {
-    /** Base URL of the Rondevu server (e.g., 'https://example.com') */
-    baseUrl: string;
-    /** Optional fetch implementation (for Node.js environments) */
-    fetch?: typeof fetch;
-}
-/**
- * WebRTC polyfill for Node.js and other non-browser platforms
- */
-export interface WebRTCPolyfill {
-    RTCPeerConnection: typeof RTCPeerConnection;
-    RTCSessionDescription: typeof RTCSessionDescription;
-    RTCIceCandidate: typeof RTCIceCandidate;
-}
-/**
- * Configuration options for Rondevu WebRTC client
- */
-export interface RondevuOptions {
-    /** Base URL of the Rondevu server (defaults to 'https://api.ronde.vu') */
-    baseUrl?: string;
-    /** Peer identifier (optional, auto-generated if not provided) */
-    peerId?: string;
-    /** Optional fetch implementation (for Node.js environments) */
-    fetch?: typeof fetch;
-    /** WebRTC configuration (ICE servers, etc.) */
-    rtcConfig?: RTCConfiguration;
-    /** Polling interval in milliseconds (default: 1000) */
-    pollingInterval?: number;
-    /** Connection timeout in milliseconds (default: 30000) */
-    connectionTimeout?: number;
-    /** WebRTC polyfill for Node.js (e.g., wrtc or @roamhq/wrtc) */
-    wrtc?: WebRTCPolyfill;
-}
-/**
- * Connection role - whether this peer is creating or answering
- */
-export type ConnectionRole = 'offerer' | 'answerer';
-/**
- * Parameters for creating a RondevuConnection
- */
-export interface RondevuConnectionParams {
-    id: string;
-    topic?: string;
-    role: ConnectionRole;
-    pc: RTCPeerConnection;
-    localPeerId: string;
-    remotePeerId: string;
-    pollingInterval: number;
-    connectionTimeout: number;
-    wrtc?: WebRTCPolyfill;
-}
-/**
- * Event map for RondevuConnection events
- */
-export interface RondevuConnectionEvents {
-    connect: () => void;
-    disconnect: () => void;
-    error: (error: Error) => void;
-    datachannel: (channel: RTCDataChannel) => void;
-    stream: (stream: MediaStream) => void;
-}

package/dist/types.js

@@ -1,4 +0,0 @@
-// ============================================================================
-// Signaling Types
-// ============================================================================
-export {};