@xtr-dev/rondevu-webtorrent 0.0.1 → 0.0.3

package/dist/RondevuConnectionManager.d.ts

@@ -1,11 +1,16 @@
 import WebTorrent from 'webtorrent';
-import { Credentials } from '@xtr-dev/rondevu-client';
+/**
+ * Credential type for rondevu authentication
+ */
+export interface Credential {
+    name: string;
+    secret: string;
+}
 /**
  * WebRTC polyfill interface for Node.js environments
  */
 export interface WebRTCPolyfill {
     RTCPeerConnection: typeof RTCPeerConnection;
-    RTCSessionDescription: typeof RTCSessionDescription;
     RTCIceCandidate: typeof RTCIceCandidate;
 }
 /**
@@ -35,7 +40,7 @@ export interface RondevuConnectionManagerOptions {
     /**
      * Existing rondevu credentials to reuse
      */
-    credentials?: Credentials;
+    credential?: Credential;
     /**
      * WebRTC polyfill for Node.js (e.g., @roamhq/wrtc)
      * Required for WebRTC functionality in Node.js environments
@@ -50,15 +55,14 @@ export interface RondevuConnectionManagerOptions {
 export declare class RondevuConnectionManager {
     private client;
     private rondevu;
+    private torrentOfferHandles;
     private torrentPeers;
-    private torrentOffers;
     private torrentCleanupHandlers;
     private refreshTimers;
-    private torrentBloomFilters;
     private options;
     constructor(client: WebTorrent.Instance, options?: RondevuConnectionManagerOptions);
     /**
-     * Initialize the connection manager by setting up event listeners and registering with rondevu
+     * Initialize the connection manager by setting up event listeners and connecting to rondevu
      */
     private initialize;
     /**
@@ -69,10 +73,6 @@ export declare class RondevuConnectionManager {
      * Discover peers for a torrent using rondevu
      */
     private discoverPeersForTorrent;
-    /**
-     * Set up event handlers for a rondevu peer
-     */
-    private setupPeerHandlers;
     /**
      * Log a message if debug mode is enabled
      */
@@ -86,7 +86,7 @@ export declare class RondevuConnectionManager {
      */
     getStats(): {
         activeTorrents: number;
-        peerId: string | undefined;
+        username: string | undefined;
         rondevuServer: string;
         torrents: {
             infoHash: string;
@@ -94,9 +94,9 @@ export declare class RondevuConnectionManager {
         }[];
     };
     /**
-     * Get the rondevu credentials for persistence
+     * Get the rondevu credential for persistence
      */
-    getCredentials(): Credentials | undefined;
+    getCredential(): Credential | undefined;
     /**
      * Clean up all resources and disconnect from rondevu
      */

package/dist/RondevuConnectionManager.js

@@ -1,4 +1,18 @@
-import { Rondevu, BloomFilter } from '@xtr-dev/rondevu-client';
+import { Rondevu } from '@xtr-dev/rondevu-client';
+/**
+ * Simple WebRTC adapter for Node.js using wrtc polyfill
+ */
+class NodeWebRTCAdapter {
+    constructor(polyfills) {
+        this.polyfills = polyfills;
+    }
+    createPeerConnection(config) {
+        return new this.polyfills.RTCPeerConnection(config);
+    }
+    createIceCandidate(candidateInit) {
+        return new this.polyfills.RTCIceCandidate(candidateInit);
+    }
+}
 /**
  * Connection manager that uses Rondevu for WebTorrent peer discovery via WebRTC.
  * This class acts as a plugin for WebTorrent, automatically discovering
@@ -6,11 +20,11 @@ import { Rondevu, BloomFilter } from '@xtr-dev/rondevu-client';
  */
 export class RondevuConnectionManager {
     constructor(client, options = {}) {
+        this.rondevu = null;
+        this.torrentOfferHandles = new Map();
         this.torrentPeers = new Map();
-        this.torrentOffers = new Map();
         this.torrentCleanupHandlers = new Map();
         this.refreshTimers = new Map();
-        this.torrentBloomFilters = new Map();
         this.client = client;
         this.options = {
             rondevuServer: options.rondevuServer,
@@ -19,32 +33,36 @@ export class RondevuConnectionManager {
             refreshInterval: options.refreshInterval ?? 30000,
             rtcConfig: options.rtcConfig,
             wrtc: options.wrtc,
+            credential: options.credential,
         };
-        this.rondevu = new Rondevu({
-            baseUrl: options.rondevuServer,
-            credentials: options.credentials,
-            RTCPeerConnection: options.wrtc?.RTCPeerConnection,
-            RTCSessionDescription: options.wrtc?.RTCSessionDescription,
-            RTCIceCandidate: options.wrtc?.RTCIceCandidate,
-        });
         this.initialize();
     }
     /**
-     * Initialize the connection manager by setting up event listeners and registering with rondevu
+     * Initialize the connection manager by setting up event listeners and connecting to rondevu
      */
     async initialize() {
         this.log('Initializing RondevuConnectionManager');
         try {
-            if (!this.rondevu.isAuthenticated()) {
-                const credentials = await this.rondevu.register();
-                this.log(`Registered with rondevu: ${credentials.peerId}`);
+            // Build connection options
+            const connectOptions = {
+                apiUrl: this.options.rondevuServer,
+                credential: this.options.credential,
+                debug: this.options.debug,
+            };
+            // Add WebRTC adapter if wrtc polyfill provided
+            if (this.options.wrtc) {
+                connectOptions.webrtcAdapter = new NodeWebRTCAdapter(this.options.wrtc);
             }
-            else {
-                this.log(`Using existing credentials: ${this.rondevu.getCredentials()?.peerId}`);
+            // Add ICE servers if custom config provided
+            if (this.options.rtcConfig?.iceServers) {
+                connectOptions.iceServers = this.options.rtcConfig.iceServers;
             }
+            // Connect to rondevu (auto-generates credentials if not provided)
+            this.rondevu = await Rondevu.connect(connectOptions);
+            this.log(`Connected to rondevu as: ${this.rondevu.getName()}`);
         }
         catch (error) {
-            this.log(`Failed to register with rondevu: ${error}`);
+            this.log(`Failed to connect to rondevu: ${error}`);
             return;
         }
         // Listen for new torrents being added
@@ -60,12 +78,14 @@ export class RondevuConnectionManager {
      * Handle a torrent being added to the WebTorrent client
      */
     async handleTorrentAdded(torrent) {
+        if (!this.rondevu) {
+            this.log('Rondevu not initialized, skipping torrent');
+            return;
+        }
         const infoHash = torrent.infoHash;
         this.log(`Torrent added: ${infoHash}`);
         // Initialize tracking for this torrent
         this.torrentPeers.set(infoHash, new Set());
-        this.torrentOffers.set(infoHash, []);
-        this.torrentBloomFilters.set(infoHash, new BloomFilter(1024, 3));
         // Start discovering peers and creating offers
         await this.discoverPeersForTorrent(torrent);
         // Set up periodic peer refresh
@@ -81,6 +101,12 @@ export class RondevuConnectionManager {
                 clearInterval(timer);
                 this.refreshTimers.delete(infoHash);
             }
+            // Cancel our offer for this torrent
+            const offerHandle = this.torrentOfferHandles.get(infoHash);
+            if (offerHandle) {
+                offerHandle.cancel();
+                this.torrentOfferHandles.delete(infoHash);
+            }
             // Close all peer connections for this torrent
             const peers = this.torrentPeers.get(infoHash);
             if (peers) {
@@ -94,21 +120,6 @@ export class RondevuConnectionManager {
                 });
                 this.torrentPeers.delete(infoHash);
             }
-            // Delete our offers for this torrent
-            const offerIds = this.torrentOffers.get(infoHash);
-            if (offerIds) {
-                offerIds.forEach(async (offerId) => {
-                    try {
-                        await this.rondevu.offers.delete(offerId);
-                    }
-                    catch (error) {
-                        this.log(`Error deleting offer: ${error}`);
-                    }
-                });
-                this.torrentOffers.delete(infoHash);
-            }
-            // Clean up bloom filter
-            this.torrentBloomFilters.delete(infoHash);
             this.torrentCleanupHandlers.delete(infoHash);
         };
         torrent.on('done', () => {
@@ -122,6 +133,8 @@ export class RondevuConnectionManager {
      * Discover peers for a torrent using rondevu
      */
     async discoverPeersForTorrent(torrent) {
+        if (!this.rondevu)
+            return;
         const infoHash = torrent.infoHash;
         const currentPeerCount = this.torrentPeers.get(infoHash)?.size ?? 0;
         // Check if we already have enough peers
@@ -130,50 +143,79 @@ export class RondevuConnectionManager {
             return;
         }
         try {
-            // Create our own offer for this torrent using rondevu.createPeer() to get WebRTC polyfills
-            const peer = this.rondevu.createPeer(this.options.rtcConfig);
-            this.log(`Creating offer for torrent ${infoHash}`);
-            const offerId = await peer.createOffer({
-                topics: [infoHash],
-                ttl: 300000, // 5 minutes in milliseconds
-                createDataChannel: true,
-                dataChannelLabel: 'webtorrent',
-            });
-            this.torrentOffers.get(infoHash)?.push(offerId);
-            // Set up peer connection handlers
-            this.setupPeerHandlers(peer, torrent, true);
+            // Create offers for this torrent if we haven't already
+            if (!this.torrentOfferHandles.has(infoHash)) {
+                this.log(`Creating offers for torrent ${infoHash}`);
+                const offerHandle = await this.rondevu.offer({
+                    tags: [infoHash],
+                    maxOffers: 3, // Maintain pool of 3 offers
+                    ttl: 300000, // 5 minutes
+                    autoStart: true,
+                });
+                this.torrentOfferHandles.set(infoHash, offerHandle);
+                // Listen for incoming connections on our offers
+                this.rondevu.on('connection:opened', (_offerId, connection) => {
+                    this.log(`Incoming connection for torrent ${infoHash}`);
+                    connection.on('connected', () => {
+                        // Add the WebRTC peer connection to the torrent
+                        try {
+                            const pc = connection.getPeerConnection();
+                            if (pc) {
+                                torrent.addPeer(pc);
+                                this.log(`Added incoming peer to torrent ${infoHash}`);
+                            }
+                        }
+                        catch (error) {
+                            this.log(`Failed to add incoming peer: ${error}`);
+                        }
+                    });
+                });
+            }
             // Discover other peers' offers for this torrent
             this.log(`Discovering peers for torrent ${infoHash}`);
-            const bloomFilter = this.torrentBloomFilters.get(infoHash);
-            const offers = await this.rondevu.offers.findByTopic(infoHash, {
+            const result = await this.rondevu.discover([infoHash], {
                 limit: this.options.maxPeersPerTorrent - currentPeerCount,
-                bloomFilter: bloomFilter?.toBytes(),
             });
-            this.log(`Found ${offers.length} offers for torrent ${infoHash}`);
-            // Connect to discovered peers
-            for (const remoteOffer of offers) {
+            this.log(`Found ${result.offers.length} offers for torrent ${infoHash}`);
+            // Connect to discovered peers using the simplified peer() API
+            for (const remoteOffer of result.offers) {
                 // Skip our own offers
-                if (remoteOffer.peerId === this.rondevu.getCredentials()?.peerId) {
-                    continue;
-                }
-                // Skip if already answered
-                if (remoteOffer.answererPeerId) {
+                if (remoteOffer.username === this.rondevu.getName()) {
                     continue;
                 }
-                // Add to bloom filter to avoid rediscovering
-                bloomFilter?.add(remoteOffer.peerId);
                 try {
-                    // Create peer using rondevu.createPeer() to get WebRTC polyfills
-                    const answerPeer = this.rondevu.createPeer(this.options.rtcConfig);
-                    this.log(`Answering offer ${remoteOffer.id} for torrent ${infoHash}`);
-                    await answerPeer.answer(remoteOffer.id, remoteOffer.sdp, {
-                        topics: [infoHash],
+                    this.log(`Connecting to peer ${remoteOffer.username} for torrent ${infoHash}`);
+                    const peer = await this.rondevu.peer({
+                        tags: [infoHash],
+                        username: remoteOffer.username,
+                    });
+                    // Track this peer
+                    this.torrentPeers.get(infoHash)?.add(peer);
+                    // Set up peer handlers
+                    peer.on('open', () => {
+                        this.log(`Connected to peer ${peer.peerUsername} for torrent ${infoHash}`);
+                        // Add the WebRTC peer connection to the torrent
+                        try {
+                            const pc = peer.peerConnection;
+                            if (pc) {
+                                torrent.addPeer(pc);
+                            }
+                        }
+                        catch (error) {
+                            this.log(`Failed to add WebRTC peer to torrent: ${error}`);
+                        }
+                    });
+                    peer.on('close', () => {
+                        this.log(`Peer disconnected for torrent ${infoHash}`);
+                        this.torrentPeers.get(infoHash)?.delete(peer);
+                    });
+                    peer.on('error', (error) => {
+                        this.log(`Peer error for torrent ${infoHash}: ${error.message}`);
+                        this.torrentPeers.get(infoHash)?.delete(peer);
                     });
-                    // Set up peer connection handlers
-                    this.setupPeerHandlers(answerPeer, torrent, false);
                 }
                 catch (error) {
-                    this.log(`Failed to answer offer ${remoteOffer.id}: ${error}`);
+                    this.log(`Failed to connect to peer ${remoteOffer.username}: ${error}`);
                 }
             }
         }
@@ -181,35 +223,6 @@ export class RondevuConnectionManager {
             this.log(`Error discovering peers for ${infoHash}: ${error}`);
         }
     }
-    /**
-     * Set up event handlers for a rondevu peer
-     */
-    setupPeerHandlers(peer, torrent, isOfferer) {
-        const infoHash = torrent.infoHash;
-        peer.on('connected', () => {
-            this.log(`Peer connected for torrent ${infoHash}`);
-            this.torrentPeers.get(infoHash)?.add(peer);
-            // Add the WebRTC peer connection to the torrent
-            // WebTorrent can use WebRTC peer connections directly
-            try {
-                torrent.addPeer(peer.pc);
-            }
-            catch (error) {
-                this.log(`Failed to add WebRTC peer to torrent: ${error}`);
-            }
-        });
-        peer.on('disconnected', () => {
-            this.log(`Peer disconnected for torrent ${infoHash}`);
-            this.torrentPeers.get(infoHash)?.delete(peer);
-        });
-        peer.on('failed', (error) => {
-            this.log(`Peer failed for torrent ${infoHash}: ${error.message}`);
-            this.torrentPeers.get(infoHash)?.delete(peer);
-        });
-        peer.on('datachannel', (channel) => {
-            this.log(`Data channel opened for torrent ${infoHash}: ${channel.label}`);
-        });
-    }
     /**
      * Log a message if debug mode is enabled
      */
@@ -239,16 +252,16 @@ export class RondevuConnectionManager {
         }));
         return {
             activeTorrents: this.client.torrents.length,
-            peerId: this.rondevu.getCredentials()?.peerId,
+            username: this.rondevu?.getName(),
             rondevuServer: this.options.rondevuServer ?? 'https://api.ronde.vu',
             torrents: torrentStats,
         };
     }
     /**
-     * Get the rondevu credentials for persistence
+     * Get the rondevu credential for persistence
      */
-    getCredentials() {
-        return this.rondevu.getCredentials();
+    getCredential() {
+        return this.rondevu?.getCredential();
     }
     /**
      * Clean up all resources and disconnect from rondevu
@@ -259,8 +272,7 @@ export class RondevuConnectionManager {
         this.torrentCleanupHandlers.forEach((cleanup) => cleanup());
         this.torrentCleanupHandlers.clear();
         this.torrentPeers.clear();
-        this.torrentOffers.clear();
+        this.torrentOfferHandles.clear();
         this.refreshTimers.clear();
-        this.torrentBloomFilters.clear();
     }
 }

package/dist/index.d.ts

@@ -1 +1 @@
-export { RondevuConnectionManager, RondevuConnectionManagerOptions } from './RondevuConnectionManager.js';
+export { RondevuConnectionManager, RondevuConnectionManagerOptions, Credential, WebRTCPolyfill } from './RondevuConnectionManager.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xtr-dev/rondevu-webtorrent",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "WebTorrent peer discovery plugin using Rondevu WebRTC signaling",
   "type": "module",
   "main": "dist/index.js",
@@ -36,7 +36,7 @@
   "homepage": "https://github.com/xtr-dev/rondevu-webtorrent#readme",
   "dependencies": {
     "@roamhq/wrtc": "^0.9.1",
-    "@xtr-dev/rondevu-client": "^0.7.4",
+    "@xtr-dev/rondevu-client": "^0.21.3",
     "webtorrent": "^2.8.4"
   },
   "devDependencies": {