@xtr-dev/rondevu-client 0.7.11 → 0.8.0

package/dist/services.js

@@ -0,0 +1,206 @@
+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/usernames.d.ts

@@ -0,0 +1,79 @@
+/**
+ * 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

@@ -0,0 +1,147 @@
+import * as ed25519 from '@noble/ed25519';
+/**
+ * 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.getPublicKey(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.sign(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 };
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xtr-dev/rondevu-client",
-  "version": "0.7.11",
-  "description": "TypeScript client for Rondevu topic-based peer discovery and signaling server",
+  "version": "0.8.0",
+  "description": "TypeScript client for Rondevu DNS-like WebRTC with username claiming and service discovery",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -27,6 +27,6 @@
     "README.md"
   ],
   "dependencies": {
-    "@xtr-dev/rondevu-client": "^0.5.1"
+    "@noble/ed25519": "^3.0.0"
   }
 }