peerpigeon 0.0.4 ā 0.0.6
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.
- package/README.md +144 -4
- package/examples/browser/app.js +40 -39
- package/examples/browser/crypto-test.html +427 -0
- package/examples/browser/index.html +161 -0
- package/examples/browser/styles.css +216 -0
- package/examples/browser/ui-old.js +1926 -0
- package/examples/browser/ui.js +2226 -1692
- package/examples/node/test-crypto-media.js +137 -0
- package/examples/node/test-crypto.js +146 -0
- package/examples/node/test-node.js +114 -115
- package/package.json +51 -8
- package/src/CleanupManager.js +154 -154
- package/src/ConnectionManager.js +772 -749
- package/src/CryptoManager.js +612 -0
- package/src/EnvironmentDetector.js +381 -381
- package/src/EventEmitter.js +19 -19
- package/src/EvictionManager.js +211 -211
- package/src/GossipManager.js +447 -366
- package/src/MediaManager.js +218 -195
- package/src/MeshOptimizer.js +165 -166
- package/src/PeerConnection.js +850 -758
- package/src/PeerDiscovery.js +255 -259
- package/src/PeerPigeonMesh.js +1082 -723
- package/src/SignalingClient.js +517 -518
- package/src/SignalingHandler.js +295 -291
- package/src/StorageManager.js +105 -105
- package/src/TimerUtils.js +29 -29
- package/src/WebDHT.js +951 -951
- package/websocket-server/server.js +371 -332
|
@@ -0,0 +1,137 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
|
|
3
|
+
import { PeerPigeonMesh } from '../../index.js';
|
|
4
|
+
import WebSocket from 'ws';
|
|
5
|
+
import wrtc from '@koush/wrtc';
|
|
6
|
+
|
|
7
|
+
// Make WebRTC available globally for Node.js
|
|
8
|
+
global.RTCPeerConnection = wrtc.RTCPeerConnection;
|
|
9
|
+
global.RTCSessionDescription = wrtc.RTCSessionDescription;
|
|
10
|
+
global.RTCIceCandidate = wrtc.RTCIceCandidate;
|
|
11
|
+
global.WebSocket = WebSocket;
|
|
12
|
+
|
|
13
|
+
// Test crypto functionality with media streams
|
|
14
|
+
console.log('šš„ PeerPigeon Crypto + Media Test\n');
|
|
15
|
+
|
|
16
|
+
async function createCryptoPeerWithMedia(peerName, enableMedia = false) {
|
|
17
|
+
const mesh = new PeerPigeonMesh({
|
|
18
|
+
enableWebDHT: true,
|
|
19
|
+
enableCrypto: true, // Enable crypto!
|
|
20
|
+
ignoreEnvironmentErrors: true
|
|
21
|
+
});
|
|
22
|
+
|
|
23
|
+
// Set up event handlers
|
|
24
|
+
mesh.addEventListener('statusChanged', (event) => {
|
|
25
|
+
console.log(`[${peerName}] Status: ${event.type} - ${event.message || ''}`);
|
|
26
|
+
});
|
|
27
|
+
|
|
28
|
+
mesh.addEventListener('peerConnected', (event) => {
|
|
29
|
+
console.log(`[${peerName}] š Connected to peer: ${event.peerId.substring(0, 8)}...`);
|
|
30
|
+
});
|
|
31
|
+
|
|
32
|
+
mesh.addEventListener('peerDisconnected', (event) => {
|
|
33
|
+
console.log(`[${peerName}] š Disconnected from peer: ${event.peerId.substring(0, 8)}... (${event.reason})`);
|
|
34
|
+
});
|
|
35
|
+
|
|
36
|
+
mesh.addEventListener('messageReceived', (event) => {
|
|
37
|
+
const fromPeerId = event.from || 'unknown';
|
|
38
|
+
console.log(`[${peerName}] šØ Received: "${event.content}" from ${fromPeerId.substring(0, 8)}...`);
|
|
39
|
+
});
|
|
40
|
+
|
|
41
|
+
// Crypto-specific events
|
|
42
|
+
mesh.addEventListener('peerKeyAdded', (event) => {
|
|
43
|
+
console.log(`[${peerName}] š Key added for peer: ${event.peerId.substring(0, 8)}...`);
|
|
44
|
+
});
|
|
45
|
+
|
|
46
|
+
mesh.addEventListener('cryptoError', (event) => {
|
|
47
|
+
console.log(`[${peerName}] š« Crypto error: ${event.error}`);
|
|
48
|
+
});
|
|
49
|
+
|
|
50
|
+
// Media events
|
|
51
|
+
mesh.addEventListener('remoteStream', (event) => {
|
|
52
|
+
console.log(`[${peerName}] š„ Remote stream received from ${event.peerId.substring(0, 8)}...`);
|
|
53
|
+
const { stream } = event;
|
|
54
|
+
const audioTracks = stream.getAudioTracks();
|
|
55
|
+
const videoTracks = stream.getVideoTracks();
|
|
56
|
+
console.log(`[${peerName}] š„ Stream has ${audioTracks.length} audio tracks, ${videoTracks.length} video tracks`);
|
|
57
|
+
});
|
|
58
|
+
|
|
59
|
+
// Initialize the mesh
|
|
60
|
+
await mesh.init();
|
|
61
|
+
console.log(`[${peerName}] Initialized with ID: ${mesh.peerId.substring(0, 8)}...`);
|
|
62
|
+
|
|
63
|
+
if (enableMedia) {
|
|
64
|
+
try {
|
|
65
|
+
console.log(`[${peerName}] Starting media stream...`);
|
|
66
|
+
// Start media stream (this will work in Node.js environment with mock streams)
|
|
67
|
+
await mesh.startMedia({ video: true, audio: true });
|
|
68
|
+
console.log(`[${peerName}] Media stream started successfully`);
|
|
69
|
+
} catch (error) {
|
|
70
|
+
console.log(`[${peerName}] Media stream failed (expected in Node.js): ${error.message}`);
|
|
71
|
+
}
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
return mesh;
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
async function testCryptoWithMedia() {
|
|
78
|
+
console.log('Testing crypto key exchange with media-enabled peers...\n');
|
|
79
|
+
|
|
80
|
+
// Create two peers - one with media, one without
|
|
81
|
+
const peer1 = await createCryptoPeerWithMedia('CRYPTO-MEDIA-PEER-1', true);
|
|
82
|
+
const peer2 = await createCryptoPeerWithMedia('CRYPTO-PEER-2', false);
|
|
83
|
+
|
|
84
|
+
console.log('\nConnecting to signaling server...\n');
|
|
85
|
+
|
|
86
|
+
// Connect to signaling server
|
|
87
|
+
await peer1.connect('ws://localhost:3000');
|
|
88
|
+
await peer2.connect('ws://localhost:3000');
|
|
89
|
+
|
|
90
|
+
// Wait for connection establishment
|
|
91
|
+
await new Promise(resolve => setTimeout(resolve, 3000));
|
|
92
|
+
|
|
93
|
+
console.log('\nTesting encrypted message exchange with media connection...\n');
|
|
94
|
+
|
|
95
|
+
// Test encrypted messaging between peers (one with media, one without)
|
|
96
|
+
try {
|
|
97
|
+
console.log('Testing sendEncryptedMessage with media-enabled peer...');
|
|
98
|
+
|
|
99
|
+
const peer1Id = peer1.peerId;
|
|
100
|
+
const peer2Id = peer2.peerId;
|
|
101
|
+
|
|
102
|
+
// Send encrypted message from media peer to regular peer
|
|
103
|
+
await peer1.sendEncryptedMessage(peer2Id, 'This is an encrypted message from the media-enabled peer');
|
|
104
|
+
await new Promise(resolve => setTimeout(resolve, 500));
|
|
105
|
+
|
|
106
|
+
// Send encrypted message from regular peer to media peer
|
|
107
|
+
await peer2.sendEncryptedMessage(peer1Id, 'This is an encrypted message to the media-enabled peer');
|
|
108
|
+
await new Promise(resolve => setTimeout(resolve, 500));
|
|
109
|
+
|
|
110
|
+
console.log('ā
Encrypted messaging test with media peer completed successfully!');
|
|
111
|
+
} catch (error) {
|
|
112
|
+
console.log(`ā Encrypted messaging test failed: ${error.message}`);
|
|
113
|
+
}
|
|
114
|
+
|
|
115
|
+
// Check crypto status
|
|
116
|
+
console.log('\n--- Crypto Status with Media ---');
|
|
117
|
+
const crypto1Status = peer1.getCryptoStatus();
|
|
118
|
+
const crypto2Status = peer2.getCryptoStatus();
|
|
119
|
+
|
|
120
|
+
console.log(`CRYPTO-MEDIA-PEER-1: enabled=${crypto1Status.enabled}, keys=${Object.keys(crypto1Status.peerKeys || {}).length}`);
|
|
121
|
+
console.log(`CRYPTO-PEER-2: enabled=${crypto2Status.enabled}, keys=${Object.keys(crypto2Status.peerKeys || {}).length}`);
|
|
122
|
+
|
|
123
|
+
console.log('\nš Crypto + Media test completed, cleaning up...\n');
|
|
124
|
+
|
|
125
|
+
// Clean up
|
|
126
|
+
peer1.disconnect();
|
|
127
|
+
peer2.disconnect();
|
|
128
|
+
|
|
129
|
+
setTimeout(() => {
|
|
130
|
+
process.exit(0);
|
|
131
|
+
}, 1000);
|
|
132
|
+
}
|
|
133
|
+
|
|
134
|
+
testCryptoWithMedia().catch(error => {
|
|
135
|
+
console.error('Crypto + Media test failed:', error);
|
|
136
|
+
process.exit(1);
|
|
137
|
+
});
|
|
@@ -0,0 +1,146 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
|
|
3
|
+
import { PeerPigeonMesh } from '../../index.js';
|
|
4
|
+
import WebSocket from 'ws';
|
|
5
|
+
import wrtc from '@koush/wrtc';
|
|
6
|
+
|
|
7
|
+
// Make WebRTC available globally for Node.js
|
|
8
|
+
global.RTCPeerConnection = wrtc.RTCPeerConnection;
|
|
9
|
+
global.RTCSessionDescription = wrtc.RTCSessionDescription;
|
|
10
|
+
global.RTCIceCandidate = wrtc.RTCIceCandidate;
|
|
11
|
+
global.WebSocket = WebSocket;
|
|
12
|
+
|
|
13
|
+
// Test crypto functionality
|
|
14
|
+
console.log('š PeerPigeon Crypto Test\n');
|
|
15
|
+
|
|
16
|
+
// Check if signaling server is running
|
|
17
|
+
async function checkSignalingServer() {
|
|
18
|
+
// Simple check - just try to create a WebSocket connection briefly
|
|
19
|
+
return true; // Assume server is running for now
|
|
20
|
+
}
|
|
21
|
+
|
|
22
|
+
async function createCryptoPeer(peerName, peerId = null) {
|
|
23
|
+
const mesh = new PeerPigeonMesh({
|
|
24
|
+
peerId,
|
|
25
|
+
enableWebDHT: true,
|
|
26
|
+
enableCrypto: true, // Enable crypto!
|
|
27
|
+
ignoreEnvironmentErrors: true
|
|
28
|
+
});
|
|
29
|
+
|
|
30
|
+
// Set up event handlers
|
|
31
|
+
mesh.addEventListener('statusChanged', (event) => {
|
|
32
|
+
console.log(`[${peerName}] Status: ${event.type} - ${event.message || ''}`);
|
|
33
|
+
});
|
|
34
|
+
|
|
35
|
+
mesh.addEventListener('peerConnected', (event) => {
|
|
36
|
+
console.log(`[${peerName}] š Connected to peer: ${event.peerId.substring(0, 8)}...`);
|
|
37
|
+
});
|
|
38
|
+
|
|
39
|
+
mesh.addEventListener('peerDisconnected', (event) => {
|
|
40
|
+
console.log(`[${peerName}] š Disconnected from peer: ${event.peerId.substring(0, 8)}... (${event.reason})`);
|
|
41
|
+
});
|
|
42
|
+
|
|
43
|
+
mesh.addEventListener('messageReceived', (event) => {
|
|
44
|
+
const fromPeerId = event.from || 'unknown';
|
|
45
|
+
console.log(`[${peerName}] šØ Received: "${event.content}" from ${fromPeerId.substring(0, 8)}...`);
|
|
46
|
+
});
|
|
47
|
+
|
|
48
|
+
// Crypto-specific events
|
|
49
|
+
mesh.addEventListener('peerKeyAdded', (event) => {
|
|
50
|
+
console.log(`[${peerName}] š Key added for peer: ${event.peerId.substring(0, 8)}...`);
|
|
51
|
+
});
|
|
52
|
+
|
|
53
|
+
mesh.addEventListener('cryptoError', (event) => {
|
|
54
|
+
console.log(`[${peerName}] š« Crypto error: ${event.error}`);
|
|
55
|
+
});
|
|
56
|
+
|
|
57
|
+
// Initialize the mesh
|
|
58
|
+
await mesh.init();
|
|
59
|
+
console.log(`[${peerName}] Initialized with ID: ${mesh.peerId.substring(0, 8)}...`);
|
|
60
|
+
|
|
61
|
+
return mesh;
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
async function testCrypto() {
|
|
65
|
+
console.log('Checking signaling server at ws://localhost:3000...');
|
|
66
|
+
const serverRunning = await checkSignalingServer();
|
|
67
|
+
if (!serverRunning) {
|
|
68
|
+
console.log('ā Signaling server not running. Start it with: npm run server');
|
|
69
|
+
process.exit(1);
|
|
70
|
+
}
|
|
71
|
+
console.log('ā
Signaling server is running\n');
|
|
72
|
+
|
|
73
|
+
console.log('Creating two crypto-enabled mesh peers...\n');
|
|
74
|
+
|
|
75
|
+
// Create two peers with crypto enabled
|
|
76
|
+
const peer1 = await createCryptoPeer('CRYPTO-PEER-1');
|
|
77
|
+
const peer2 = await createCryptoPeer('CRYPTO-PEER-2');
|
|
78
|
+
|
|
79
|
+
console.log('\nConnecting to signaling server...\n');
|
|
80
|
+
|
|
81
|
+
// Connect to signaling server
|
|
82
|
+
await peer1.connect('ws://localhost:3000');
|
|
83
|
+
await peer2.connect('ws://localhost:3000');
|
|
84
|
+
|
|
85
|
+
// Wait for connection establishment
|
|
86
|
+
await new Promise(resolve => setTimeout(resolve, 3000));
|
|
87
|
+
|
|
88
|
+
console.log('\nTesting encrypted message exchange...\n');
|
|
89
|
+
|
|
90
|
+
// Test direct encrypted messaging between peers
|
|
91
|
+
try {
|
|
92
|
+
console.log('Testing sendEncryptedMessage...');
|
|
93
|
+
|
|
94
|
+
// Get the peer IDs for direct encrypted messaging
|
|
95
|
+
const peer1Id = peer1.peerId;
|
|
96
|
+
const peer2Id = peer2.peerId;
|
|
97
|
+
|
|
98
|
+
// Send encrypted message from peer1 to peer2
|
|
99
|
+
await peer1.sendEncryptedMessage(peer2Id, 'This is an encrypted message from peer 1');
|
|
100
|
+
await new Promise(resolve => setTimeout(resolve, 500));
|
|
101
|
+
|
|
102
|
+
// Send encrypted message from peer2 to peer1
|
|
103
|
+
await peer2.sendEncryptedMessage(peer1Id, 'This is an encrypted message from peer 2');
|
|
104
|
+
await new Promise(resolve => setTimeout(resolve, 500));
|
|
105
|
+
|
|
106
|
+
console.log('ā
Encrypted messaging test completed successfully!');
|
|
107
|
+
} catch (error) {
|
|
108
|
+
console.log(`ā Encrypted messaging test failed: ${error.message}`);
|
|
109
|
+
console.log('Falling back to regular messaging...');
|
|
110
|
+
|
|
111
|
+
// Fallback to regular messaging
|
|
112
|
+
peer1.sendMessage('Hello unencrypted world from peer 1!');
|
|
113
|
+
await new Promise(resolve => setTimeout(resolve, 500));
|
|
114
|
+
|
|
115
|
+
peer2.sendMessage('Hello unencrypted world from peer 2!');
|
|
116
|
+
await new Promise(resolve => setTimeout(resolve, 500));
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
// Test a few more regular messages
|
|
120
|
+
for (let i = 1; i <= 2; i++) {
|
|
121
|
+
peer1.sendMessage(`Test message #${i}`);
|
|
122
|
+
await new Promise(resolve => setTimeout(resolve, 500));
|
|
123
|
+
peer2.sendMessage(`Response #${i}`);
|
|
124
|
+
await new Promise(resolve => setTimeout(resolve, 500));
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
console.log('\n--- Crypto Stats ---');
|
|
128
|
+
console.log(`CRYPTO-PEER-1: ${peer1.getConnectedPeerCount()} connected peers`);
|
|
129
|
+
console.log(`CRYPTO-PEER-2: ${peer2.getConnectedPeerCount()} connected peers`);
|
|
130
|
+
|
|
131
|
+
console.log('\nš Crypto test completed, cleaning up...\n');
|
|
132
|
+
|
|
133
|
+
// Clean up
|
|
134
|
+
peer1.disconnect();
|
|
135
|
+
peer2.disconnect();
|
|
136
|
+
|
|
137
|
+
// Give time for cleanup
|
|
138
|
+
setTimeout(() => {
|
|
139
|
+
process.exit(0);
|
|
140
|
+
}, 1000);
|
|
141
|
+
}
|
|
142
|
+
|
|
143
|
+
testCrypto().catch(error => {
|
|
144
|
+
console.error('Crypto test failed:', error);
|
|
145
|
+
process.exit(1);
|
|
146
|
+
});
|
|
@@ -3,7 +3,7 @@
|
|
|
3
3
|
/**
|
|
4
4
|
* Node.js Test for PeerPigeon Mesh Networking
|
|
5
5
|
* Demonstrates P2P mesh functionality in Node.js environment
|
|
6
|
-
*
|
|
6
|
+
*
|
|
7
7
|
* Prerequisites:
|
|
8
8
|
* - npm install ws @koush/wrtc
|
|
9
9
|
* - Start signaling server: npm run server
|
|
@@ -25,129 +25,128 @@ const TEST_DURATION = 30000; // 30 seconds
|
|
|
25
25
|
console.log('ļæ½ PeerPigeon Node.js Mesh Test\n');
|
|
26
26
|
|
|
27
27
|
async function createPeer(peerName, peerId = null) {
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
28
|
+
const mesh = new PeerPigeonMesh({
|
|
29
|
+
peerId,
|
|
30
|
+
enableWebDHT: true,
|
|
31
|
+
ignoreEnvironmentErrors: true
|
|
32
|
+
});
|
|
33
|
+
|
|
34
|
+
// Set up event handlers
|
|
35
|
+
mesh.addEventListener('statusChanged', (event) => {
|
|
36
|
+
console.log(`[${peerName}] Status: ${event.type} - ${event.message || ''}`);
|
|
37
|
+
});
|
|
38
|
+
|
|
39
|
+
mesh.addEventListener('peerConnected', (event) => {
|
|
40
|
+
console.log(`[${peerName}] š Connected to peer: ${event.peerId.substring(0, 8)}...`);
|
|
41
|
+
});
|
|
42
|
+
|
|
43
|
+
mesh.addEventListener('peerDisconnected', (event) => {
|
|
44
|
+
console.log(`[${peerName}] š Disconnected from peer: ${event.peerId.substring(0, 8)}... (${event.reason})`);
|
|
45
|
+
});
|
|
46
|
+
|
|
47
|
+
mesh.addEventListener('messageReceived', (event) => {
|
|
48
|
+
const fromPeerId = event.from || 'unknown';
|
|
49
|
+
console.log(`[${peerName}] šØ Received: "${event.content}" from ${fromPeerId.substring(0, 8)}...`);
|
|
50
|
+
});
|
|
51
|
+
|
|
52
|
+
// Initialize the mesh
|
|
53
|
+
await mesh.init();
|
|
54
|
+
console.log(`[${peerName}] Initialized with ID: ${mesh.peerId.substring(0, 8)}...`);
|
|
55
|
+
|
|
56
|
+
// Display environment info
|
|
57
|
+
const envReport = mesh.getEnvironmentReport();
|
|
58
|
+
console.log(`[${peerName}] Environment: Node.js ${envReport.node?.version}, WebRTC: ${envReport.capabilities.webrtc}, WebSocket: ${envReport.capabilities.webSocket}`);
|
|
59
|
+
|
|
60
|
+
return mesh;
|
|
61
61
|
}
|
|
62
62
|
|
|
63
63
|
async function runTest() {
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
}
|
|
64
|
+
try {
|
|
65
|
+
console.log('Creating two mesh peers...\n');
|
|
66
|
+
|
|
67
|
+
// Create two peers
|
|
68
|
+
const peer1 = await createPeer('PEER-1');
|
|
69
|
+
const peer2 = await createPeer('PEER-2');
|
|
70
|
+
|
|
71
|
+
console.log('\nConnecting to signaling server...\n');
|
|
72
|
+
|
|
73
|
+
// Connect both peers to signaling server
|
|
74
|
+
await peer1.connect(SIGNALING_URL);
|
|
75
|
+
await peer2.connect(SIGNALING_URL);
|
|
76
|
+
|
|
77
|
+
// Wait for connections to establish
|
|
78
|
+
await new Promise(resolve => setTimeout(resolve, 2000));
|
|
79
|
+
|
|
80
|
+
console.log('\nTesting message exchange...\n');
|
|
81
|
+
|
|
82
|
+
// Test messaging
|
|
83
|
+
let messageCount = 0;
|
|
84
|
+
const sendMessage = () => {
|
|
85
|
+
messageCount++;
|
|
86
|
+
const message = `Hello from Node.js test #${messageCount}`;
|
|
87
|
+
|
|
88
|
+
if (messageCount % 2 === 1) {
|
|
89
|
+
console.log(`[PEER-1] š¤ Sending: "${message}"`);
|
|
90
|
+
peer1.sendMessage(message);
|
|
91
|
+
} else {
|
|
92
|
+
console.log(`[PEER-2] š¤ Sending: "${message}"`);
|
|
93
|
+
peer2.sendMessage(message);
|
|
94
|
+
}
|
|
95
|
+
};
|
|
96
|
+
|
|
97
|
+
// Send messages every 3 seconds
|
|
98
|
+
const messageInterval = setInterval(sendMessage, 3000);
|
|
99
|
+
sendMessage(); // Send first message immediately
|
|
100
|
+
|
|
101
|
+
// Test DHT functionality
|
|
102
|
+
setTimeout(async () => {
|
|
103
|
+
console.log('\nTesting DHT functionality...\n');
|
|
104
|
+
try {
|
|
105
|
+
await peer1.dhtPut('test-key', { data: 'Hello from Node.js DHT!', timestamp: Date.now() });
|
|
106
|
+
console.log('[PEER-1] š Stored data in DHT');
|
|
107
|
+
|
|
108
|
+
const value = await peer2.dhtGet('test-key');
|
|
109
|
+
console.log('[PEER-2] š Retrieved from DHT:', value);
|
|
110
|
+
} catch (error) {
|
|
111
|
+
console.error('DHT test failed:', error.message);
|
|
112
|
+
}
|
|
113
|
+
}, 5000);
|
|
114
|
+
|
|
115
|
+
// Display stats periodically
|
|
116
|
+
const statsInterval = setInterval(() => {
|
|
117
|
+
const peer1ConnectedCount = peer1.getConnectedPeerCount();
|
|
118
|
+
const peer2ConnectedCount = peer2.getConnectedPeerCount();
|
|
119
|
+
console.log('\n--- Stats ---');
|
|
120
|
+
console.log(`PEER-1: ${peer1ConnectedCount} connected peers`);
|
|
121
|
+
console.log(`PEER-2: ${peer2ConnectedCount} connected peers`);
|
|
122
|
+
}, 10000);
|
|
123
|
+
|
|
124
|
+
// Run test for specified duration
|
|
125
|
+
setTimeout(() => {
|
|
126
|
+
console.log('\nš Test completed, cleaning up...\n');
|
|
127
|
+
clearInterval(messageInterval);
|
|
128
|
+
clearInterval(statsInterval);
|
|
129
|
+
|
|
130
|
+
peer1.disconnect();
|
|
131
|
+
peer2.disconnect();
|
|
132
|
+
|
|
133
|
+
process.exit(0);
|
|
134
|
+
}, TEST_DURATION);
|
|
135
|
+
} catch (error) {
|
|
136
|
+
console.error('ā Test failed:', error);
|
|
137
|
+
process.exit(1);
|
|
138
|
+
}
|
|
140
139
|
}
|
|
141
140
|
|
|
142
141
|
// Check if signaling server is running
|
|
143
142
|
console.log(`Checking signaling server at ${SIGNALING_URL}...`);
|
|
144
143
|
const testWs = new WebSocket(SIGNALING_URL);
|
|
145
144
|
testWs.on('open', () => {
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
145
|
+
testWs.close();
|
|
146
|
+
console.log('ā
Signaling server is running\n');
|
|
147
|
+
runTest();
|
|
149
148
|
});
|
|
150
149
|
testWs.on('error', () => {
|
|
151
|
-
|
|
152
|
-
|
|
150
|
+
console.error('ā Signaling server not running. Start it with: npm run server');
|
|
151
|
+
process.exit(1);
|
|
153
152
|
});
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "peerpigeon",
|
|
3
|
-
"version": "0.0.
|
|
3
|
+
"version": "0.0.6",
|
|
4
4
|
"description": "WebRTC-based peer-to-peer mesh networking library with intelligent routing and signaling server",
|
|
5
5
|
"main": "index.js",
|
|
6
6
|
"type": "module",
|
|
@@ -13,9 +13,20 @@
|
|
|
13
13
|
"dev": "http-server . -p 8080 -c-1",
|
|
14
14
|
"start": "node websocket-server/server.js",
|
|
15
15
|
"server": "node websocket-server/server.js",
|
|
16
|
-
"test": "
|
|
17
|
-
"
|
|
18
|
-
"
|
|
16
|
+
"test": "NODE_OPTIONS='--experimental-vm-modules --no-warnings' jest",
|
|
17
|
+
"test:unit": "NODE_OPTIONS='--experimental-vm-modules --no-warnings' jest test/unit",
|
|
18
|
+
"test:integration": "NODE_OPTIONS='--experimental-vm-modules --no-warnings' jest test/integration",
|
|
19
|
+
"test:media": "NODE_OPTIONS='--experimental-vm-modules --no-warnings' jest test/unit/media-simple.test.js",
|
|
20
|
+
"test:media-only": "NODE_OPTIONS='--experimental-vm-modules --no-warnings' jest test/unit/media-only.test.js",
|
|
21
|
+
"test:coverage": "NODE_OPTIONS='--experimental-vm-modules --no-warnings' jest --coverage",
|
|
22
|
+
"test:watch": "jest --watch",
|
|
23
|
+
"test:custom": "node test/unit/crypto.test.js && node test/unit/mesh.test.js && node test/integration/integration.test.js",
|
|
24
|
+
"test:all": "node test/runner.js",
|
|
25
|
+
"lint": "eslint src/ examples/ websocket-server/ --ext .js",
|
|
26
|
+
"lint:fix": "eslint src/ examples/ websocket-server/ --ext .js --fix",
|
|
27
|
+
"benchmark": "node test/benchmark.js",
|
|
28
|
+
"ci": "npm run lint && npm run test:unit",
|
|
29
|
+
"prepublishOnly": "npm run ci"
|
|
19
30
|
},
|
|
20
31
|
"files": [
|
|
21
32
|
"index.js",
|
|
@@ -53,11 +64,17 @@
|
|
|
53
64
|
},
|
|
54
65
|
"homepage": "https://github.com/draeder/peerpigeon#readme",
|
|
55
66
|
"dependencies": {
|
|
56
|
-
"
|
|
57
|
-
"
|
|
67
|
+
"@koush/wrtc": "^0.5.3",
|
|
68
|
+
"unsea": "^1.1.0",
|
|
69
|
+
"ws": "^8.18.0"
|
|
58
70
|
},
|
|
59
71
|
"devDependencies": {
|
|
60
|
-
"
|
|
72
|
+
"@jest/globals": "^30.0.5",
|
|
73
|
+
"c8": "^10.1.3",
|
|
74
|
+
"eslint": "^8.57.1",
|
|
75
|
+
"eslint-config-standard": "^17.1.0",
|
|
76
|
+
"http-server": "^14.1.1",
|
|
77
|
+
"jest": "^30.0.5"
|
|
61
78
|
},
|
|
62
79
|
"engines": {
|
|
63
80
|
"node": ">=14.0.0"
|
|
@@ -66,5 +83,31 @@
|
|
|
66
83
|
"last 2 versions",
|
|
67
84
|
"not dead",
|
|
68
85
|
"> 1%"
|
|
69
|
-
]
|
|
86
|
+
],
|
|
87
|
+
"jest": {
|
|
88
|
+
"testEnvironment": "node",
|
|
89
|
+
"globals": {
|
|
90
|
+
"__DEV__": true
|
|
91
|
+
},
|
|
92
|
+
"transform": {},
|
|
93
|
+
"testMatch": [
|
|
94
|
+
"**/test/**/*.test.js"
|
|
95
|
+
],
|
|
96
|
+
"collectCoverageFrom": [
|
|
97
|
+
"src/**/*.js",
|
|
98
|
+
"!src/**/*.test.js"
|
|
99
|
+
],
|
|
100
|
+
"coverageDirectory": "coverage",
|
|
101
|
+
"coverageReporters": [
|
|
102
|
+
"text",
|
|
103
|
+
"lcov",
|
|
104
|
+
"html"
|
|
105
|
+
],
|
|
106
|
+
"verbose": true,
|
|
107
|
+
"setupFilesAfterEnv": ["<rootDir>/test/setup.js"],
|
|
108
|
+
"testTimeout": 30000,
|
|
109
|
+
"detectOpenHandles": true,
|
|
110
|
+
"forceExit": true,
|
|
111
|
+
"clearMocks": true
|
|
112
|
+
}
|
|
70
113
|
}
|