peerpigeon 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (54) hide show
  1. package/LICENSE +21 -0
  2. package/README.md +1187 -0
  3. package/examples/browser/app-dht-disabled.js +42 -0
  4. package/examples/browser/app.js +51 -0
  5. package/examples/browser/assets/images/favicon.png +0 -0
  6. package/examples/browser/assets/images/pigeon.png +0 -0
  7. package/examples/browser/index-dht-disabled.html +123 -0
  8. package/examples/browser/index.html +340 -0
  9. package/examples/browser/styles.css +1288 -0
  10. package/examples/browser/ui-clean.js +0 -0
  11. package/examples/browser/ui.js +1930 -0
  12. package/index.js +8 -0
  13. package/package.json +70 -0
  14. package/server/index.js +515 -0
  15. package/src/CleanupManager.js +181 -0
  16. package/src/ConnectionManager.js +841 -0
  17. package/src/EventEmitter.js +27 -0
  18. package/src/EvictionManager.js +257 -0
  19. package/src/GossipManager.js +416 -0
  20. package/src/MediaManager.js +225 -0
  21. package/src/MeshOptimizer.js +181 -0
  22. package/src/PeerConnection.js +831 -0
  23. package/src/PeerDiscovery.js +297 -0
  24. package/src/PeerPigeonMesh.js +703 -0
  25. package/src/SignalingClient.js +536 -0
  26. package/src/SignalingHandler.js +325 -0
  27. package/src/StorageManager.js +88 -0
  28. package/src/TimerUtils.js +46 -0
  29. package/src/WebDHT.js +1099 -0
  30. package/websocket-server/README.md +257 -0
  31. package/websocket-server/memory-leak-test.js +193 -0
  32. package/websocket-server/node_modules/.package-lock.json +29 -0
  33. package/websocket-server/node_modules/ws/LICENSE +20 -0
  34. package/websocket-server/node_modules/ws/README.md +548 -0
  35. package/websocket-server/node_modules/ws/browser.js +8 -0
  36. package/websocket-server/node_modules/ws/index.js +13 -0
  37. package/websocket-server/node_modules/ws/lib/buffer-util.js +131 -0
  38. package/websocket-server/node_modules/ws/lib/constants.js +18 -0
  39. package/websocket-server/node_modules/ws/lib/event-target.js +292 -0
  40. package/websocket-server/node_modules/ws/lib/extension.js +203 -0
  41. package/websocket-server/node_modules/ws/lib/limiter.js +55 -0
  42. package/websocket-server/node_modules/ws/lib/permessage-deflate.js +528 -0
  43. package/websocket-server/node_modules/ws/lib/receiver.js +706 -0
  44. package/websocket-server/node_modules/ws/lib/sender.js +602 -0
  45. package/websocket-server/node_modules/ws/lib/stream.js +161 -0
  46. package/websocket-server/node_modules/ws/lib/subprotocol.js +62 -0
  47. package/websocket-server/node_modules/ws/lib/validation.js +152 -0
  48. package/websocket-server/node_modules/ws/lib/websocket-server.js +550 -0
  49. package/websocket-server/node_modules/ws/lib/websocket.js +1388 -0
  50. package/websocket-server/node_modules/ws/package.json +69 -0
  51. package/websocket-server/node_modules/ws/wrapper.mjs +8 -0
  52. package/websocket-server/package-lock.json +39 -0
  53. package/websocket-server/server.js +298 -0
  54. package/websocket-server/test.js +133 -0
package/index.js ADDED
@@ -0,0 +1,8 @@
1
+ // Main entry point for PeerPigeon npm package
2
+ export { PeerPigeonMesh } from './src/PeerPigeonMesh.js';
3
+ export { PeerConnection } from './src/PeerConnection.js';
4
+ export { SignalingClient } from './src/SignalingClient.js';
5
+ export { WebDHT } from './src/WebDHT.js';
6
+
7
+ // Export the WebSocket server class for programmatic use
8
+ export { PeerPigeonServer } from './server/index.js';
package/package.json ADDED
@@ -0,0 +1,70 @@
1
+ {
2
+ "name": "peerpigeon",
3
+ "version": "0.0.1",
4
+ "description": "WebRTC-based peer-to-peer mesh networking library with intelligent routing and signaling server",
5
+ "main": "index.js",
6
+ "type": "module",
7
+ "exports": {
8
+ ".": {
9
+ "import": "./index.js"
10
+ }
11
+ },
12
+ "scripts": {
13
+ "dev": "http-server . -p 8080 -c-1",
14
+ "start": "node websocket-server/server.js",
15
+ "server": "node websocket-server/server.js",
16
+ "test": "echo 'No tests configured yet'",
17
+ "lint": "echo 'No linting configured yet'",
18
+ "prepublishOnly": "echo 'Ready for npm publish'"
19
+ },
20
+ "files": [
21
+ "index.js",
22
+ "src/",
23
+ "server/",
24
+ "websocket-server/",
25
+ "examples/",
26
+ "README.md",
27
+ "LICENSE"
28
+ ],
29
+ "repository": {
30
+ "type": "git",
31
+ "url": "git+https://github.com/draeder/peerpigeon.git"
32
+ },
33
+ "keywords": [
34
+ "webrtc",
35
+ "p2p",
36
+ "mesh",
37
+ "networking",
38
+ "decentralized",
39
+ "kademlia",
40
+ "signaling",
41
+ "websocket",
42
+ "peer-to-peer",
43
+ "dht",
44
+ "gossip",
45
+ "mesh-network",
46
+ "xor-routing",
47
+ "webrtc-mesh"
48
+ ],
49
+ "author": "Daniel Raeder",
50
+ "license": "MIT",
51
+ "bugs": {
52
+ "url": "https://github.com/draeder/peerpigeon/issues"
53
+ },
54
+ "homepage": "https://github.com/draeder/peerpigeon#readme",
55
+ "dependencies": {
56
+ "ws": "^8.18.0"
57
+ },
58
+ "devDependencies": {
59
+ "@koush/wrtc": "^0.5.3",
60
+ "http-server": "^14.1.1"
61
+ },
62
+ "engines": {
63
+ "node": ">=14.0.0"
64
+ },
65
+ "browserslist": [
66
+ "last 2 versions",
67
+ "not dead",
68
+ "> 1%"
69
+ ]
70
+ }
@@ -0,0 +1,515 @@
1
+ // PeerPigeon WebSocket Server - Node.js module
2
+ import { WebSocketServer } from 'ws';
3
+ import { createServer } from 'http';
4
+ import { EventEmitter } from 'events';
5
+
6
+ /**
7
+ * PeerPigeon WebSocket signaling server
8
+ * Can be used programmatically or as a standalone server
9
+ */
10
+ export class PeerPigeonServer extends EventEmitter {
11
+ constructor(options = {}) {
12
+ super();
13
+
14
+ this.port = options.port || 3000;
15
+ this.host = options.host || 'localhost';
16
+ this.maxConnections = options.maxConnections || 1000;
17
+ this.cleanupInterval = options.cleanupInterval || 60000; // 1 minute
18
+ this.peerTimeout = options.peerTimeout || 300000; // 5 minutes
19
+ this.corsOrigin = options.corsOrigin || '*';
20
+ this.maxMessageSize = options.maxMessageSize || 1048576; // 1MB
21
+
22
+ this.httpServer = null;
23
+ this.wss = null;
24
+ this.connections = new Map(); // peerId -> WebSocket
25
+ this.peerData = new Map(); // peerId -> peer info
26
+ this.isRunning = false;
27
+ this.cleanupTimer = null;
28
+ }
29
+
30
+ /**
31
+ * Start the WebSocket server
32
+ */
33
+ async start() {
34
+ if (this.isRunning) {
35
+ throw new Error('Server is already running');
36
+ }
37
+
38
+ return new Promise((resolve, reject) => {
39
+ try {
40
+ // Create HTTP server
41
+ this.httpServer = createServer((req, res) => {
42
+ // Handle CORS preflight
43
+ if (req.method === 'OPTIONS') {
44
+ res.writeHead(200, {
45
+ 'Access-Control-Allow-Origin': this.corsOrigin,
46
+ 'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
47
+ 'Access-Control-Allow-Headers': 'Content-Type, Authorization'
48
+ });
49
+ res.end();
50
+ return;
51
+ }
52
+
53
+ // Health check endpoint
54
+ if (req.url === '/health') {
55
+ res.writeHead(200, {
56
+ 'Content-Type': 'application/json',
57
+ 'Access-Control-Allow-Origin': this.corsOrigin
58
+ });
59
+ res.end(JSON.stringify({
60
+ status: 'healthy',
61
+ timestamp: new Date().toISOString(),
62
+ uptime: process.uptime(),
63
+ connections: this.connections.size,
64
+ peers: this.peerData.size,
65
+ memory: process.memoryUsage()
66
+ }));
67
+ return;
68
+ }
69
+
70
+ // Default response
71
+ res.writeHead(200, {
72
+ 'Content-Type': 'text/plain',
73
+ 'Access-Control-Allow-Origin': this.corsOrigin
74
+ });
75
+ res.end('PeerPigeon WebSocket Signaling Server');
76
+ });
77
+
78
+ // Create WebSocket server
79
+ this.wss = new WebSocketServer({
80
+ server: this.httpServer,
81
+ maxPayload: this.maxMessageSize
82
+ });
83
+
84
+ this.setupWebSocketHandlers();
85
+
86
+ // Start HTTP server
87
+ this.httpServer.listen(this.port, this.host, () => {
88
+ this.isRunning = true;
89
+ this.startCleanupTimer();
90
+
91
+ console.log(`🚀 PeerPigeon WebSocket server started on ws://${this.host}:${this.port}`);
92
+ console.log(`📊 Max connections: ${this.maxConnections}`);
93
+ console.log(`🧹 Cleanup interval: ${this.cleanupInterval}ms`);
94
+ console.log(`⏰ Peer timeout: ${this.peerTimeout}ms`);
95
+
96
+ this.emit('started', { host: this.host, port: this.port });
97
+ resolve();
98
+ });
99
+
100
+ this.httpServer.on('error', (error) => {
101
+ console.error('❌ HTTP server error:', error);
102
+ this.emit('error', error);
103
+ reject(error);
104
+ });
105
+
106
+ } catch (error) {
107
+ console.error('❌ Failed to start server:', error);
108
+ reject(error);
109
+ }
110
+ });
111
+ }
112
+
113
+ /**
114
+ * Stop the WebSocket server
115
+ */
116
+ async stop() {
117
+ if (!this.isRunning) {
118
+ return;
119
+ }
120
+
121
+ return new Promise((resolve) => {
122
+ console.log('🛑 Stopping PeerPigeon WebSocket server...');
123
+
124
+ // Stop cleanup timer
125
+ if (this.cleanupTimer) {
126
+ clearInterval(this.cleanupTimer);
127
+ this.cleanupTimer = null;
128
+ }
129
+
130
+ // Close all WebSocket connections
131
+ for (const [peerId, ws] of this.connections) {
132
+ try {
133
+ ws.close(1000, 'Server shutting down');
134
+ } catch (error) {
135
+ console.error(`Error closing connection for ${peerId}:`, error);
136
+ }
137
+ }
138
+
139
+ // Close WebSocket server
140
+ if (this.wss) {
141
+ this.wss.close(() => {
142
+ console.log('✅ WebSocket server closed');
143
+
144
+ // Close HTTP server
145
+ if (this.httpServer) {
146
+ this.httpServer.close(() => {
147
+ console.log('✅ HTTP server closed');
148
+ this.isRunning = false;
149
+ this.emit('stopped');
150
+ resolve();
151
+ });
152
+ } else {
153
+ this.isRunning = false;
154
+ this.emit('stopped');
155
+ resolve();
156
+ }
157
+ });
158
+ } else {
159
+ this.isRunning = false;
160
+ this.emit('stopped');
161
+ resolve();
162
+ }
163
+ });
164
+ }
165
+
166
+ /**
167
+ * Setup WebSocket connection handlers
168
+ */
169
+ setupWebSocketHandlers() {
170
+ this.wss.on('connection', (ws, req) => {
171
+ const url = new URL(req.url, `http://${req.headers.host}`);
172
+ const peerId = url.searchParams.get('peerId');
173
+
174
+ // Validate peer ID
175
+ if (!peerId || !/^[a-fA-F0-9]{40}$/.test(peerId)) {
176
+ console.log('❌ Invalid peer ID, closing connection');
177
+ ws.close(1008, 'Invalid peerId format');
178
+ return;
179
+ }
180
+
181
+ // Check connection limit
182
+ if (this.connections.size >= this.maxConnections) {
183
+ console.log('❌ Maximum connections reached, closing connection');
184
+ ws.close(1008, 'Maximum connections reached');
185
+ return;
186
+ }
187
+
188
+ // Store connection
189
+ this.connections.set(peerId, ws);
190
+ this.peerData.set(peerId, {
191
+ peerId,
192
+ connectedAt: Date.now(),
193
+ lastActivity: Date.now(),
194
+ remoteAddress: req.socket.remoteAddress
195
+ });
196
+
197
+ console.log(`✅ Peer connected: ${peerId.substring(0, 8)}... (${this.connections.size} total)`);
198
+ this.emit('peerConnected', { peerId, totalConnections: this.connections.size });
199
+
200
+ // Handle incoming messages
201
+ ws.on('message', (data) => {
202
+ try {
203
+ this.handleMessage(peerId, data);
204
+ } catch (error) {
205
+ console.error(`❌ Error handling message from ${peerId.substring(0, 8)}...:`, error);
206
+ }
207
+ });
208
+
209
+ // Handle connection close
210
+ ws.on('close', (code, reason) => {
211
+ this.handleDisconnection(peerId, code, reason);
212
+ });
213
+
214
+ // Handle connection error
215
+ ws.on('error', (error) => {
216
+ console.error(`❌ WebSocket error for ${peerId.substring(0, 8)}...:`, error);
217
+ this.handleDisconnection(peerId, 1006, 'WebSocket error');
218
+ });
219
+
220
+ // Send connected confirmation
221
+ this.sendToConnection(ws, {
222
+ type: 'connected',
223
+ data: { peerId },
224
+ fromPeerId: 'system',
225
+ timestamp: Date.now()
226
+ });
227
+ });
228
+
229
+ this.wss.on('error', (error) => {
230
+ console.error('❌ WebSocket server error:', error);
231
+ this.emit('error', error);
232
+ });
233
+ }
234
+
235
+ /**
236
+ * Handle incoming messages from peers
237
+ */
238
+ handleMessage(peerId, data) {
239
+ // Update last activity
240
+ const peerInfo = this.peerData.get(peerId);
241
+ if (peerInfo) {
242
+ peerInfo.lastActivity = Date.now();
243
+ }
244
+
245
+ let message;
246
+ try {
247
+ message = JSON.parse(data.toString());
248
+ } catch (error) {
249
+ console.error(`❌ Invalid JSON from ${peerId.substring(0, 8)}...:`, error);
250
+ return;
251
+ }
252
+
253
+ // Log message type
254
+ console.log(`📨 Message from ${peerId.substring(0, 8)}...: ${message.type}`);
255
+
256
+ switch (message.type) {
257
+ case 'announce':
258
+ this.handleAnnounce(peerId, message);
259
+ break;
260
+ case 'goodbye':
261
+ this.handleGoodbye(peerId, message);
262
+ break;
263
+ case 'offer':
264
+ case 'answer':
265
+ case 'ice-candidate':
266
+ this.handleSignaling(peerId, message);
267
+ break;
268
+ case 'ping':
269
+ this.handlePing(peerId, message);
270
+ break;
271
+ case 'cleanup':
272
+ this.handleCleanup(peerId, message);
273
+ break;
274
+ default:
275
+ console.log(`❓ Unknown message type from ${peerId.substring(0, 8)}...: ${message.type}`);
276
+ }
277
+ }
278
+
279
+ /**
280
+ * Handle peer announcement
281
+ */
282
+ handleAnnounce(peerId, message) {
283
+ console.log(`📢 Peer announced: ${peerId.substring(0, 8)}...`);
284
+
285
+ // Update peer data
286
+ const peerInfo = this.peerData.get(peerId);
287
+ if (peerInfo) {
288
+ peerInfo.announced = true;
289
+ peerInfo.announcedAt = Date.now();
290
+ }
291
+
292
+ // Notify other peers about this peer
293
+ this.broadcastToOthers(peerId, {
294
+ type: 'peer-discovered',
295
+ data: {
296
+ peerId,
297
+ timestamp: Date.now(),
298
+ ...message.data
299
+ },
300
+ fromPeerId: 'system',
301
+ timestamp: Date.now()
302
+ });
303
+
304
+ this.emit('peerAnnounced', { peerId });
305
+ }
306
+
307
+ /**
308
+ * Handle peer goodbye
309
+ */
310
+ handleGoodbye(peerId, message) {
311
+ console.log(`👋 Peer goodbye: ${peerId.substring(0, 8)}...`);
312
+
313
+ // Notify other peers about disconnection
314
+ this.broadcastToOthers(peerId, {
315
+ type: 'peer-disconnected',
316
+ data: {
317
+ peerId,
318
+ reason: message.data?.reason || 'goodbye',
319
+ timestamp: Date.now()
320
+ },
321
+ fromPeerId: 'system',
322
+ timestamp: Date.now()
323
+ });
324
+
325
+ // Remove peer
326
+ this.removePeer(peerId);
327
+ this.emit('peerGoodbye', { peerId });
328
+ }
329
+
330
+ /**
331
+ * Handle WebRTC signaling messages
332
+ */
333
+ handleSignaling(peerId, message) {
334
+ const targetPeerId = message.targetPeerId;
335
+ if (!targetPeerId) {
336
+ console.log(`❌ No target peer ID in signaling message from ${peerId.substring(0, 8)}...`);
337
+ return;
338
+ }
339
+
340
+ const targetConnection = this.connections.get(targetPeerId);
341
+ if (!targetConnection) {
342
+ console.log(`❌ Target peer ${targetPeerId.substring(0, 8)}... not found for signaling`);
343
+ return;
344
+ }
345
+
346
+ // Forward signaling message to target peer
347
+ this.sendToConnection(targetConnection, {
348
+ ...message,
349
+ fromPeerId: peerId,
350
+ timestamp: Date.now()
351
+ });
352
+
353
+ console.log(`🔄 Forwarded ${message.type} from ${peerId.substring(0, 8)}... to ${targetPeerId.substring(0, 8)}...`);
354
+ }
355
+
356
+ /**
357
+ * Handle ping messages
358
+ */
359
+ handlePing(peerId, message) {
360
+ const connection = this.connections.get(peerId);
361
+ if (connection) {
362
+ this.sendToConnection(connection, {
363
+ type: 'pong',
364
+ data: { timestamp: Date.now() },
365
+ fromPeerId: 'system',
366
+ targetPeerId: peerId,
367
+ timestamp: Date.now()
368
+ });
369
+ }
370
+ }
371
+
372
+ /**
373
+ * Handle cleanup messages
374
+ */
375
+ handleCleanup(peerId, message) {
376
+ console.log(`🧹 Cleanup request from ${peerId.substring(0, 8)}...`);
377
+ // Cleanup is handled by the cleanup timer
378
+ // This is just for logging purposes
379
+ }
380
+
381
+ /**
382
+ * Handle peer disconnection
383
+ */
384
+ handleDisconnection(peerId, code, reason) {
385
+ console.log(`❌ Peer disconnected: ${peerId.substring(0, 8)}... (code: ${code}, reason: ${reason})`);
386
+
387
+ // Notify other peers about disconnection
388
+ this.broadcastToOthers(peerId, {
389
+ type: 'peer-disconnected',
390
+ data: {
391
+ peerId,
392
+ reason: reason?.toString() || 'disconnected',
393
+ timestamp: Date.now()
394
+ },
395
+ fromPeerId: 'system',
396
+ timestamp: Date.now()
397
+ });
398
+
399
+ // Remove peer
400
+ this.removePeer(peerId);
401
+ this.emit('peerDisconnected', { peerId, code, reason, totalConnections: this.connections.size });
402
+ }
403
+
404
+ /**
405
+ * Remove peer from server
406
+ */
407
+ removePeer(peerId) {
408
+ this.connections.delete(peerId);
409
+ this.peerData.delete(peerId);
410
+ console.log(`🗑️ Removed peer: ${peerId.substring(0, 8)}... (${this.connections.size} remaining)`);
411
+ }
412
+
413
+ /**
414
+ * Send message to specific connection
415
+ */
416
+ sendToConnection(connection, message) {
417
+ if (connection.readyState === connection.OPEN) {
418
+ try {
419
+ connection.send(JSON.stringify(message));
420
+ return true;
421
+ } catch (error) {
422
+ console.error('❌ Failed to send message:', error);
423
+ return false;
424
+ }
425
+ }
426
+ return false;
427
+ }
428
+
429
+ /**
430
+ * Broadcast message to all peers except the sender
431
+ */
432
+ broadcastToOthers(senderPeerId, message) {
433
+ let sentCount = 0;
434
+ for (const [peerId, connection] of this.connections) {
435
+ if (peerId !== senderPeerId) {
436
+ if (this.sendToConnection(connection, {
437
+ ...message,
438
+ targetPeerId: peerId
439
+ })) {
440
+ sentCount++;
441
+ }
442
+ }
443
+ }
444
+ console.log(`📡 Broadcast to ${sentCount} peers`);
445
+ return sentCount;
446
+ }
447
+
448
+ /**
449
+ * Start cleanup timer
450
+ */
451
+ startCleanupTimer() {
452
+ this.cleanupTimer = setInterval(() => {
453
+ this.performCleanup();
454
+ }, this.cleanupInterval);
455
+ }
456
+
457
+ /**
458
+ * Perform cleanup of inactive connections
459
+ */
460
+ performCleanup() {
461
+ const now = Date.now();
462
+ const disconnectedPeers = [];
463
+
464
+ for (const [peerId, peerInfo] of this.peerData) {
465
+ if (now - peerInfo.lastActivity > this.peerTimeout) {
466
+ console.log(`🧹 Cleaning up inactive peer: ${peerId.substring(0, 8)}...`);
467
+
468
+ const connection = this.connections.get(peerId);
469
+ if (connection) {
470
+ try {
471
+ connection.close(1000, 'Inactive timeout');
472
+ } catch (error) {
473
+ console.error(`Error closing inactive connection for ${peerId}:`, error);
474
+ }
475
+ }
476
+
477
+ disconnectedPeers.push(peerId);
478
+ }
479
+ }
480
+
481
+ // Remove disconnected peers
482
+ disconnectedPeers.forEach(peerId => {
483
+ this.removePeer(peerId);
484
+ });
485
+
486
+ if (disconnectedPeers.length > 0) {
487
+ console.log(`🧹 Cleaned up ${disconnectedPeers.length} inactive peers`);
488
+ }
489
+ }
490
+
491
+ /**
492
+ * Get server statistics
493
+ */
494
+ getStats() {
495
+ return {
496
+ isRunning: this.isRunning,
497
+ connections: this.connections.size,
498
+ peers: this.peerData.size,
499
+ maxConnections: this.maxConnections,
500
+ uptime: this.isRunning ? Date.now() - this.startTime : 0,
501
+ host: this.host,
502
+ port: this.port
503
+ };
504
+ }
505
+
506
+ /**
507
+ * Get list of connected peers
508
+ */
509
+ getPeers() {
510
+ return Array.from(this.peerData.values());
511
+ }
512
+ }
513
+
514
+ // For backwards compatibility and standalone usage
515
+ export default PeerPigeonServer;