@xtr-dev/rondevu-webtorrent 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 XTR Development
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,300 @@
+# @xtr-dev/rondevu-webtorrent
+
+> **⚠️ EARLY DEVELOPMENT WARNING**: This package is in early development (version < 1.0.0). The API is subject to change, and there may be bugs or incomplete features. Use at your own risk in production environments.
+
+WebTorrent peer discovery plugin using [Rondevu](https://github.com/xtr-dev/rondevu) WebRTC signaling for peer connectivity.
+
+## Overview
+
+`@xtr-dev/rondevu-webtorrent` acts as a plugin for [WebTorrent](https://webtorrent.io/), providing automatic peer discovery through the Rondevu WebRTC signaling service. It complements traditional BitTorrent peer discovery methods (DHT, trackers) by using WebRTC data channels for direct peer-to-peer connections.
+
+## Features
+
+- **Automatic Peer Discovery**: Automatically discovers and connects to peers for each torrent
+- **WebRTC Signaling**: Uses Rondevu for WebRTC offer/answer exchange and ICE candidate signaling
+- **Topic-Based Discovery**: Each torrent's `infoHash` is used as a topic for peer discovery
+- **Bloom Filter Optimization**: Uses bloom filters to avoid rediscovering peers, reducing bandwidth and API calls
+- **Configurable**: Control max peers per torrent, refresh intervals, and WebRTC configuration
+- **Credential Persistence**: Save and reuse Rondevu credentials across sessions
+- **Debug Mode**: Enable detailed logging to monitor peer discovery and connections
+
+## Installation
+
+```bash
+npm install @xtr-dev/rondevu-webtorrent
+```
+
+## Demo
+
+A complete working demo is available in the [`demo/`](./demo) folder. The demo includes:
+- **Seeder script** - Creates and seeds a torrent
+- **Leecher script** - Downloads the torrent
+- Step-by-step instructions
+
+See the [demo README](./demo/README.md) for details.
+
+## Quick Start
+
+### Browser
+
+```typescript
+import WebTorrent from 'webtorrent';
+import { RondevuConnectionManager } from '@xtr-dev/rondevu-webtorrent';
+
+// Create WebTorrent client
+const client = new WebTorrent();
+
+// Initialize Rondevu connection manager
+const connectionManager = new RondevuConnectionManager(client, {
+  rondevuServer: 'https://api.ronde.vu', // Optional: defaults to this
+  maxPeersPerTorrent: 50,
+  debug: true,
+  refreshInterval: 30000, // 30 seconds
+});
+
+// Add a torrent
+const magnetURI = 'magnet:?xt=urn:btih:...';
+client.add(magnetURI, (torrent) => {
+  console.log(`Torrent added: ${torrent.name}`);
+
+  torrent.on('download', () => {
+    console.log(`Progress: ${(torrent.progress * 100).toFixed(2)}%`);
+    console.log(`Peers: ${torrent.numPeers}`);
+  });
+
+  torrent.on('done', () => {
+    console.log('Download complete!');
+  });
+});
+```
+
+### Node.js (with WebRTC polyfill)
+
+```typescript
+import WebTorrent from 'webtorrent';
+import { RondevuConnectionManager } from '@xtr-dev/rondevu-webtorrent';
+import wrtc from '@roamhq/wrtc';
+
+const client = new WebTorrent();
+
+// Initialize with wrtc polyfill for Node.js
+const connectionManager = new RondevuConnectionManager(client, {
+  rondevuServer: 'https://api.ronde.vu',
+  maxPeersPerTorrent: 50,
+  debug: true,
+  wrtc: wrtc, // Required for WebRTC in Node.js
+});
+
+// Rest is the same as browser...
+```
+
+## API
+
+### `RondevuConnectionManager`
+
+The main class that manages peer discovery for WebTorrent.
+
+#### Constructor
+
+```typescript
+new RondevuConnectionManager(client: WebTorrent.Instance, options?: RondevuConnectionManagerOptions)
+```
+
+#### Options
+
+```typescript
+interface RondevuConnectionManagerOptions {
+  /**
+   * Rondevu server base URL
+   * @default 'https://api.ronde.vu'
+   */
+  rondevuServer?: string;
+
+  /**
+   * Maximum number of peer connections per torrent
+   * @default 50
+   */
+  maxPeersPerTorrent?: number;
+
+  /**
+   * Enable debug logging
+   * @default false
+   */
+  debug?: boolean;
+
+  /**
+   * Interval in milliseconds to refresh peer discovery
+   * @default 30000 (30 seconds)
+   */
+  refreshInterval?: number;
+
+  /**
+   * Custom RTCConfiguration for WebRTC peer connections
+   */
+  rtcConfig?: RTCConfiguration;
+
+  /**
+   * Existing Rondevu credentials to reuse
+   */
+  credentials?: { peerId: string; secret: string };
+
+  /**
+   * WebRTC polyfill for Node.js (e.g., @roamhq/wrtc)
+   * Required for WebRTC functionality in Node.js environments
+   */
+  wrtc?: {
+    RTCPeerConnection: typeof RTCPeerConnection;
+    RTCSessionDescription: typeof RTCSessionDescription;
+    RTCIceCandidate: typeof RTCIceCandidate;
+  };
+}
+```
+
+#### Methods
+
+##### `discoverPeers(infoHash: string): Promise<void>`
+
+Manually trigger peer discovery for a specific torrent.
+
+```typescript
+await connectionManager.discoverPeers(torrent.infoHash);
+```
+
+##### `getStats()`
+
+Get statistics about the connection manager.
+
+```typescript
+const stats = connectionManager.getStats();
+console.log(stats);
+// {
+//   activeTorrents: 1,
+//   peerId: 'abc123...',
+//   rondevuServer: 'https://api.ronde.vu',
+//   torrents: [
+//     { infoHash: '...', peerCount: 5 }
+//   ]
+// }
+```
+
+##### `getCredentials(): Credentials | undefined`
+
+Get the current Rondevu credentials for persistence across sessions.
+
+```typescript
+const credentials = connectionManager.getCredentials();
+// Save credentials to storage
+localStorage.setItem('rondevu-credentials', JSON.stringify(credentials));
+
+// Later, reuse credentials
+const savedCredentials = JSON.parse(localStorage.getItem('rondevu-credentials'));
+const newManager = new RondevuConnectionManager(client, {
+  credentials: savedCredentials
+});
+```
+
+##### `destroy(): void`
+
+Clean up all resources and disconnect from Rondevu.
+
+```typescript
+connectionManager.destroy();
+```
+
+## How It Works
+
+1. **Initialization**: When you create a `RondevuConnectionManager`, it registers with the Rondevu signaling server
+2. **Torrent Added**: When a torrent is added to WebTorrent:
+   - The manager creates a bloom filter to track seen peers
+   - The manager creates a WebRTC offer and publishes it to Rondevu with the torrent's `infoHash` as the topic
+   - The manager queries Rondevu for other peers offering the same `infoHash`, passing the bloom filter to exclude already-seen peers
+   - WebRTC connections are established with discovered peers
+   - Each discovered peer ID is added to the bloom filter
+3. **Peer Connection**: Once WebRTC connections are established, the peer connections are added to the WebTorrent instance
+4. **Periodic Refresh**: The manager periodically refreshes peer discovery to find new peers, using the bloom filter to avoid reconnecting to already-seen peers
+5. **Cleanup**: When a torrent is removed, all associated peer connections, offers, and bloom filters are cleaned up
+
+## Advanced Usage
+
+### Custom RTCConfiguration
+
+Provide custom STUN/TURN servers for WebRTC connections:
+
+```typescript
+const connectionManager = new RondevuConnectionManager(client, {
+  rtcConfig: {
+    iceServers: [
+      { urls: 'stun:stun.l.google.com:19302' },
+      {
+        urls: 'turn:turn.example.com:3478',
+        username: 'user',
+        credential: 'pass'
+      }
+    ]
+  }
+});
+```
+
+### Persistent Credentials
+
+Save and reuse credentials to maintain the same peer ID:
+
+```typescript
+// First time
+const manager = new RondevuConnectionManager(client, { debug: true });
+
+// Save credentials after initialization
+setTimeout(() => {
+  const credentials = manager.getCredentials();
+  fs.writeFileSync('credentials.json', JSON.stringify(credentials));
+}, 1000);
+
+// Next time
+const savedCredentials = JSON.parse(fs.readFileSync('credentials.json', 'utf8'));
+const manager = new RondevuConnectionManager(client, {
+  credentials: savedCredentials
+});
+```
+
+### Graceful Shutdown
+
+Always clean up when your application exits:
+
+```typescript
+process.on('SIGINT', () => {
+  console.log('Shutting down...');
+  connectionManager.destroy();
+  client.destroy(() => {
+    console.log('WebTorrent client destroyed');
+    process.exit(0);
+  });
+});
+```
+
+## Limitations
+
+- **Node.js WebRTC Support**: Node.js doesn't have native WebRTC support. To enable WebRTC functionality in Node.js, you need to install and pass a WebRTC polyfill like `@roamhq/wrtc` via the `wrtc` option (see the Node.js Quick Start example above). The polyfill requires native compilation during installation. Without the polyfill, the package will still work in Node.js using WebTorrent's traditional peer discovery methods (DHT, trackers), but Rondevu WebRTC peer discovery will not be available.
+- **Browser Support**: WebRTC works natively in modern browsers, making this the ideal environment for full Rondevu WebRTC functionality without requiring any polyfills
+- **Network Requirements**: The Rondevu signaling server must be accessible to all peers
+- **Restrictive Networks**: WebRTC connections may not work in restrictive network environments without TURN servers
+
+## Roadmap
+
+- [x] Bloom filter support for efficient peer discovery
+- [ ] Better error handling and recovery
+- [ ] Metrics and monitoring
+- [ ] Connection pooling and optimization
+- [ ] Automated testing suite
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please open an issue or pull request on GitHub.
+
+## Related Projects
+
+- [WebTorrent](https://webtorrent.io/) - Streaming torrent client for Node.js and the browser
+- [Rondevu](https://github.com/xtr-dev/rondevu) - WebRTC signaling and peer discovery service

package/dist/RondevuConnectionManager.d.ts

@@ -0,0 +1,104 @@
+import WebTorrent from 'webtorrent';
+import { Credentials } from '@xtr-dev/rondevu-client';
+/**
+ * WebRTC polyfill interface for Node.js environments
+ */
+export interface WebRTCPolyfill {
+    RTCPeerConnection: typeof RTCPeerConnection;
+    RTCSessionDescription: typeof RTCSessionDescription;
+    RTCIceCandidate: typeof RTCIceCandidate;
+}
+/**
+ * Options for configuring the RondevuConnectionManager
+ */
+export interface RondevuConnectionManagerOptions {
+    /**
+     * Rondevu server base URL (default: 'https://api.ronde.vu')
+     */
+    rondevuServer?: string;
+    /**
+     * Maximum number of peer connections to establish per torrent (default: 50)
+     */
+    maxPeersPerTorrent?: number;
+    /**
+     * Enable debug logging
+     */
+    debug?: boolean;
+    /**
+     * Interval in milliseconds to refresh peer discovery (default: 30000ms)
+     */
+    refreshInterval?: number;
+    /**
+     * Custom RTCConfiguration for WebRTC peer connections
+     */
+    rtcConfig?: RTCConfiguration;
+    /**
+     * Existing rondevu credentials to reuse
+     */
+    credentials?: Credentials;
+    /**
+     * WebRTC polyfill for Node.js (e.g., @roamhq/wrtc)
+     * Required for WebRTC functionality in Node.js environments
+     */
+    wrtc?: WebRTCPolyfill;
+}
+/**
+ * Connection manager that uses Rondevu for WebTorrent peer discovery via WebRTC.
+ * This class acts as a plugin for WebTorrent, automatically discovering
+ * and connecting to peers through rondevu WebRTC signaling.
+ */
+export declare class RondevuConnectionManager {
+    private client;
+    private rondevu;
+    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
+     */
+    private initialize;
+    /**
+     * Handle a torrent being added to the WebTorrent client
+     */
+    private handleTorrentAdded;
+    /**
+     * 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
+     */
+    private log;
+    /**
+     * Manually trigger peer discovery for a specific torrent
+     */
+    discoverPeers(infoHash: string): Promise<void>;
+    /**
+     * Get statistics about the connection manager
+     */
+    getStats(): {
+        activeTorrents: number;
+        peerId: string | undefined;
+        rondevuServer: string;
+        torrents: {
+            infoHash: string;
+            peerCount: number;
+        }[];
+    };
+    /**
+     * Get the rondevu credentials for persistence
+     */
+    getCredentials(): Credentials | undefined;
+    /**
+     * Clean up all resources and disconnect from rondevu
+     */
+    destroy(): void;
+}

package/dist/RondevuConnectionManager.js

@@ -0,0 +1,266 @@
+import { Rondevu, BloomFilter } from '@xtr-dev/rondevu-client';
+/**
+ * Connection manager that uses Rondevu for WebTorrent peer discovery via WebRTC.
+ * This class acts as a plugin for WebTorrent, automatically discovering
+ * and connecting to peers through rondevu WebRTC signaling.
+ */
+export class RondevuConnectionManager {
+    constructor(client, options = {}) {
+        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,
+            maxPeersPerTorrent: options.maxPeersPerTorrent ?? 50,
+            debug: options.debug ?? false,
+            refreshInterval: options.refreshInterval ?? 30000,
+            rtcConfig: options.rtcConfig,
+            wrtc: options.wrtc,
+        };
+        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
+     */
+    async initialize() {
+        this.log('Initializing RondevuConnectionManager');
+        try {
+            if (!this.rondevu.isAuthenticated()) {
+                const credentials = await this.rondevu.register();
+                this.log(`Registered with rondevu: ${credentials.peerId}`);
+            }
+            else {
+                this.log(`Using existing credentials: ${this.rondevu.getCredentials()?.peerId}`);
+            }
+        }
+        catch (error) {
+            this.log(`Failed to register with rondevu: ${error}`);
+            return;
+        }
+        // Listen for new torrents being added
+        this.client.on('torrent', (torrent) => {
+            this.handleTorrentAdded(torrent);
+        });
+        // Handle existing torrents if any
+        this.client.torrents.forEach((torrent) => {
+            this.handleTorrentAdded(torrent);
+        });
+    }
+    /**
+     * Handle a torrent being added to the WebTorrent client
+     */
+    async handleTorrentAdded(torrent) {
+        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
+        const refreshTimer = setInterval(() => {
+            this.discoverPeersForTorrent(torrent);
+        }, this.options.refreshInterval);
+        this.refreshTimers.set(infoHash, refreshTimer);
+        // Set up cleanup handler for when torrent is destroyed
+        const cleanup = () => {
+            this.log(`Cleaning up torrent ${infoHash}`);
+            const timer = this.refreshTimers.get(infoHash);
+            if (timer) {
+                clearInterval(timer);
+                this.refreshTimers.delete(infoHash);
+            }
+            // Close all peer connections for this torrent
+            const peers = this.torrentPeers.get(infoHash);
+            if (peers) {
+                peers.forEach((peer) => {
+                    try {
+                        peer.close();
+                    }
+                    catch (error) {
+                        this.log(`Error closing peer: ${error}`);
+                    }
+                });
+                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', () => {
+            this.log(`Torrent ${infoHash} completed`);
+        });
+        // Clean up when torrent is destroyed
+        torrent.once('destroyed', cleanup);
+        this.torrentCleanupHandlers.set(infoHash, cleanup);
+    }
+    /**
+     * Discover peers for a torrent using rondevu
+     */
+    async discoverPeersForTorrent(torrent) {
+        const infoHash = torrent.infoHash;
+        const currentPeerCount = this.torrentPeers.get(infoHash)?.size ?? 0;
+        // Check if we already have enough peers
+        if (currentPeerCount >= this.options.maxPeersPerTorrent) {
+            this.log(`Max peers reached for ${infoHash}`);
+            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);
+            // 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, {
+                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) {
+                // Skip our own offers
+                if (remoteOffer.peerId === this.rondevu.getCredentials()?.peerId) {
+                    continue;
+                }
+                // Skip if already answered
+                if (remoteOffer.answererPeerId) {
+                    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],
+                    });
+                    // Set up peer connection handlers
+                    this.setupPeerHandlers(answerPeer, torrent, false);
+                }
+                catch (error) {
+                    this.log(`Failed to answer offer ${remoteOffer.id}: ${error}`);
+                }
+            }
+        }
+        catch (error) {
+            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
+     */
+    log(message) {
+        if (this.options.debug) {
+            console.log(`[RondevuConnectionManager] ${message}`);
+        }
+    }
+    /**
+     * Manually trigger peer discovery for a specific torrent
+     */
+    async discoverPeers(infoHash) {
+        const torrent = this.client.torrents.find((t) => t.infoHash === infoHash);
+        if (!torrent) {
+            this.log(`Torrent ${infoHash} not found`);
+            return;
+        }
+        await this.discoverPeersForTorrent(torrent);
+    }
+    /**
+     * Get statistics about the connection manager
+     */
+    getStats() {
+        const torrentStats = Array.from(this.torrentPeers.entries()).map(([infoHash, peers]) => ({
+            infoHash,
+            peerCount: peers.size,
+        }));
+        return {
+            activeTorrents: this.client.torrents.length,
+            peerId: this.rondevu.getCredentials()?.peerId,
+            rondevuServer: this.options.rondevuServer ?? 'https://api.ronde.vu',
+            torrents: torrentStats,
+        };
+    }
+    /**
+     * Get the rondevu credentials for persistence
+     */
+    getCredentials() {
+        return this.rondevu.getCredentials();
+    }
+    /**
+     * Clean up all resources and disconnect from rondevu
+     */
+    destroy() {
+        this.log('Destroying RondevuConnectionManager');
+        // Run all cleanup handlers
+        this.torrentCleanupHandlers.forEach((cleanup) => cleanup());
+        this.torrentCleanupHandlers.clear();
+        this.torrentPeers.clear();
+        this.torrentOffers.clear();
+        this.refreshTimers.clear();
+        this.torrentBloomFilters.clear();
+    }
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,40 @@
+import WebTorrent from 'webtorrent';
+import { RondevuConnectionManager } from './RondevuConnectionManager.js';
+export { RondevuConnectionManager } from './RondevuConnectionManager.js';
+// Example usage
+// Check if this file is being run directly (not imported)
+const isMainModule = import.meta.url === `file://${process.argv[1]}`;
+if (isMainModule) {
+    const client = new WebTorrent();
+    // Initialize the Rondevu connection manager
+    const connectionManager = new RondevuConnectionManager(client, {
+        rondevuServer: 'https://api.ronde.vu', // Optional: defaults to this
+        maxPeersPerTorrent: 50,
+        debug: true,
+        refreshInterval: 30000, // 30 seconds
+    });
+    // Add a torrent (example with a magnet link)
+    const magnetURI = 'magnet:?xt=urn:btih:08ada5a7a6183aae1e09d831df6748d566095a10';
+    client.add(magnetURI, (torrent) => {
+        console.log(`Torrent added: ${torrent.name}`);
+        console.log(`Info hash: ${torrent.infoHash}`);
+        torrent.on('download', () => {
+            console.log(`Progress: ${(torrent.progress * 100).toFixed(2)}%`);
+            console.log(`Peers: ${torrent.numPeers}`);
+            console.log(`Download speed: ${(torrent.downloadSpeed / 1024).toFixed(2)} KB/s`);
+        });
+        torrent.on('done', () => {
+            console.log('Download complete!');
+            console.log('Stats:', connectionManager.getStats());
+        });
+    });
+    // Graceful shutdown
+    process.on('SIGINT', () => {
+        console.log('\nShutting down...');
+        connectionManager.destroy();
+        client.destroy(() => {
+            console.log('WebTorrent client destroyed');
+            process.exit(0);
+        });
+    });
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@xtr-dev/rondevu-webtorrent",
+  "version": "0.0.1",
+  "description": "WebTorrent peer discovery plugin using Rondevu WebRTC signaling",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "demo:seed": "npm run build && node demo/seed.mjs",
+    "demo:leech": "npm run build && node demo/leech.mjs"
+  },
+  "keywords": [
+    "webtorrent",
+    "rondevu",
+    "webrtc",
+    "peer-discovery",
+    "bittorrent",
+    "p2p"
+  ],
+  "author": "XTR Development",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xtr-dev/rondevu-webtorrent.git"
+  },
+  "bugs": {
+    "url": "https://github.com/xtr-dev/rondevu-webtorrent/issues"
+  },
+  "homepage": "https://github.com/xtr-dev/rondevu-webtorrent#readme",
+  "dependencies": {
+    "@roamhq/wrtc": "^0.9.1",
+    "@xtr-dev/rondevu-client": "^0.7.4",
+    "webtorrent": "^2.8.4"
+  },
+  "devDependencies": {
+    "@types/webtorrent": "^0.110.1",
+    "typescript": "^5.5.3"
+  }
+}