@ruvector/edge-net 0.1.0 → 0.1.2

package/README.md

@@ -29,12 +29,14 @@ A distributed computing platform that enables collective resource sharing for AI
 
 ## Table of Contents
 
+- [WebRTC P2P Networking](#webrtc-p2p-networking)
 - [What is Edge-Net?](#what-is-edge-net)
 - [Key Features](#key-features)
 - [Quick Start](#quick-start)
 - [How It Works](#how-it-works)
 - [AI Computing Tasks](#ai-computing-tasks)
 - [Pi-Key Identity System](#pi-key-identity-system)
+- [Security Architecture](#security-architecture)
 - [Self-Optimization](#self-optimization)
 - [Tutorials](#tutorials)
 - [API Reference](#api-reference)
@@ -45,6 +47,123 @@ A distributed computing platform that enables collective resource sharing for AI
 
 ---
 
+## WebRTC P2P Networking
+
+Edge-net implements **real WebRTC peer-to-peer connectivity** for direct browser-to-browser communication, with Google Cloud genesis nodes for global coordination.
+
+### P2P Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                    WEBRTC P2P NETWORK ARCHITECTURE                           │
+├─────────────────────────────────────────────────────────────────────────────┤
+│                                                                             │
+│   ┌─────────────┐     Signaling      ┌─────────────┐                        │
+│   │  Browser A  │◄──────────────────►│   Relay     │  (WebSocket)           │
+│   │  (Node 1)   │   offer/answer     │   Server    │                        │
+│   └──────┬──────┘     ICE candidates └─────────────┘                        │
+│          │                                                                  │
+│          │ WebRTC Data Channel (DTLS encrypted, direct P2P)                 │
+│          │                                                                  │
+│          ▼                                                                  │
+│   ┌─────────────┐                    ┌─────────────┐                        │
+│   │  Browser B  │◄──────────────────►│  Browser C  │                        │
+│   │  (Node 2)   │   Direct P2P       │  (Node 3)   │                        │
+│   └─────────────┘                    └─────────────┘                        │
+│                                                                             │
+│   Genesis Nodes (Google Cloud):                                             │
+│   • us-central1  • europe-west1  • asia-east1                               │
+│                                                                             │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+### WebRTC Features
+
+| Feature | Description |
+|---------|-------------|
+| **Real P2P Data Channels** | Direct browser-to-browser communication |
+| **ICE/STUN/TURN** | NAT traversal with Google STUN servers |
+| **DTLS Encryption** | End-to-end encrypted data channels |
+| **WebSocket Signaling** | Relay server for connection establishment |
+| **Automatic Reconnection** | Self-healing connections with exponential backoff |
+| **Heartbeat Monitoring** | Connection health with 5s heartbeat |
+| **Connection Quality Metrics** | Latency, throughput, packet loss tracking |
+| **Fallback Simulation** | Offline mode when signaling unavailable |
+
+### Genesis Nodes (Google Cloud)
+
+| Region | Host | Purpose |
+|--------|------|---------|
+| **us-central1** | edge-net-genesis-us.ruvector.dev | Americas coordination |
+| **europe-west1** | edge-net-genesis-eu.ruvector.dev | EMEA coordination |
+| **asia-east1** | edge-net-genesis-asia.ruvector.dev | APAC coordination |
+
+### WebRTC Security
+
+| Security Feature | Implementation |
+|-----------------|----------------|
+| **DTLS 1.2+** | Data channel encryption |
+| **SCTP** | Reliable ordered delivery |
+| **Origin Validation** | CORS whitelist for browser connections |
+| **Rate Limiting** | 100 msg/min per node |
+| **Message Size Limits** | 64KB max message size |
+| **Connection Limits** | 5 connections per IP |
+| **Heartbeat Timeout** | 30s stale connection cleanup |
+| **SDP Sanitization** | Prevent injection attacks |
+
+### Relay Server
+
+The relay server (`relay/index.js`) handles:
+
+```javascript
+// WebRTC signaling message types
+'webrtc_offer'     // Relay SDP offer to target peer
+'webrtc_answer'    // Relay SDP answer back
+'webrtc_ice'       // Relay ICE candidates
+'webrtc_disconnect' // Notify peer of disconnection
+```
+
+### Testing & Benchmarks
+
+```bash
+cd examples/edge-net/relay
+npm install
+node index.js &
+
+cd ../test
+npm install
+
+# Run P2P connectivity test
+npm test
+
+# Run security audit
+npm run security
+
+# Run latency benchmark
+npm run benchmark
+```
+
+### Browser Integration
+
+```javascript
+// join.html implements real WebRTC
+const WEBRTC_CONFIG = {
+    iceServers: [
+        { urls: 'stun:stun.l.google.com:19302' },
+        { urls: 'stun:stun1.l.google.com:19302' },
+    ]
+};
+
+// Connects to relay server
+const RELAY_URL = 'ws://localhost:8080';
+
+// Real peer connections via RTCPeerConnection
+const pc = new RTCPeerConnection(WEBRTC_CONFIG);
+const channel = pc.createDataChannel('edge-net');
+```
+
+---
+
 ## What is Edge-Net?
 
 Edge-net creates a **collective computing network** where participants share idle browser resources to power distributed AI workloads. Think of it as a cooperative where:

package/cli.js

@@ -7,21 +7,77 @@
  *
  * Usage:
  *   npx @ruvector/edge-net [command] [options]
- *
- * Commands:
- *   start       Start an edge-net node
- *   benchmark   Run performance benchmarks
- *   info        Show package information
- *   demo        Run interactive demo
  */
 
-import { readFileSync, existsSync } from 'fs';
+import { readFileSync, existsSync, statSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
+import { webcrypto } from 'crypto';
+import { performance } from 'perf_hooks';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+// Setup Node.js polyfills for web APIs BEFORE loading WASM
+async function setupPolyfills() {
+  // Crypto API
+  if (typeof globalThis.crypto === 'undefined') {
+    globalThis.crypto = webcrypto;
+  }
+
+  // Performance API
+  if (typeof globalThis.performance === 'undefined') {
+    globalThis.performance = performance;
+  }
+
+  // In-memory storage
+  const createStorage = () => {
+    const store = new Map();
+    return {
+      getItem: (key) => store.get(key) || null,
+      setItem: (key, value) => store.set(key, String(value)),
+      removeItem: (key) => store.delete(key),
+      clear: () => store.clear(),
+      get length() { return store.size; },
+      key: (i) => [...store.keys()][i] || null,
+    };
+  };
+
+  // Get CPU count synchronously
+  let cpuCount = 4;
+  try {
+    const os = await import('os');
+    cpuCount = os.cpus().length;
+  } catch {}
+
+  // Mock window object
+  if (typeof globalThis.window === 'undefined') {
+    globalThis.window = {
+      crypto: globalThis.crypto,
+      performance: globalThis.performance,
+      localStorage: createStorage(),
+      sessionStorage: createStorage(),
+      navigator: {
+        userAgent: `Node.js/${process.version}`,
+        language: 'en-US',
+        languages: ['en-US', 'en'],
+        hardwareConcurrency: cpuCount,
+      },
+      location: { href: 'node://localhost', hostname: 'localhost' },
+      screen: { width: 1920, height: 1080, colorDepth: 24 },
+    };
+  }
+
+  // Mock document
+  if (typeof globalThis.document === 'undefined') {
+    globalThis.document = {
+      createElement: () => ({}),
+      body: {},
+      head: {},
+    };
+  }
+}
+
 // ANSI colors
 const colors = {
   reset: '\x1b[0m',
@@ -53,20 +109,25 @@ function printHelp() {
 
 ${c('bold', 'COMMANDS:')}
   ${c('green', 'start')}       Start an edge-net node in the terminal
+  ${c('green', 'join')}        Join network with public key (multi-contributor support)
   ${c('green', 'benchmark')}   Run performance benchmarks
   ${c('green', 'info')}        Show package and WASM information
   ${c('green', 'demo')}        Run interactive demonstration
+  ${c('green', 'test')}        Test WASM module loading
   ${c('green', 'help')}        Show this help message
 
 ${c('bold', 'EXAMPLES:')}
   ${c('dim', '# Start a node')}
   $ npx @ruvector/edge-net start
 
+  ${c('dim', '# Join with new identity (multi-contributor)')}
+  $ npx @ruvector/edge-net join --generate
+
   ${c('dim', '# Run benchmarks')}
   $ npx @ruvector/edge-net benchmark
 
-  ${c('dim', '# Show info')}
-  $ npx @ruvector/edge-net info
+  ${c('dim', '# Test WASM loading')}
+  $ npx @ruvector/edge-net test
 
 ${c('bold', 'FEATURES:')}
   ${c('magenta', '⏱️  Time Crystal')}   - Distributed coordination via period-doubled oscillations
@@ -87,18 +148,17 @@ ${c('dim', 'Documentation: https://github.com/ruvnet/ruvector/tree/main/examples
 async function showInfo() {
   printBanner();
 
-  // Read package.json
   const pkgPath = join(__dirname, 'package.json');
   const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
 
-  // Check WASM file
   const wasmPath = join(__dirname, 'ruvector_edge_net_bg.wasm');
+  const nodeWasmPath = join(__dirname, 'node', 'ruvector_edge_net_bg.wasm');
   const wasmExists = existsSync(wasmPath);
-  let wasmSize = 0;
-  if (wasmExists) {
-    const stats = await import('fs').then(fs => fs.statSync(wasmPath));
-    wasmSize = stats.size;
-  }
+  const nodeWasmExists = existsSync(nodeWasmPath);
+
+  let wasmSize = 0, nodeWasmSize = 0;
+  if (wasmExists) wasmSize = statSync(wasmPath).size;
+  if (nodeWasmExists) nodeWasmSize = statSync(nodeWasmPath).size;
 
   console.log(`${c('bold', 'PACKAGE INFO:')}
   ${c('cyan', 'Name:')}        ${pkg.name}
@@ -106,15 +166,18 @@ async function showInfo() {
   ${c('cyan', 'License:')}     ${pkg.license}
   ${c('cyan', 'Type:')}        ${pkg.type}
 
-${c('bold', 'WASM MODULE:')}
-  ${c('cyan', 'File:')}        ruvector_edge_net_bg.wasm
-  ${c('cyan', 'Exists:')}      ${wasmExists ? c('green', '✓ Yes') : c('red', '✗ No')}
-  ${c('cyan', 'Size:')}        ${(wasmSize / 1024 / 1024).toFixed(2)} MB
+${c('bold', 'WASM MODULES:')}
+  ${c('cyan', 'Web Target:')}   ${wasmExists ? c('green', '✓') : c('red', '✗')} ${(wasmSize / 1024 / 1024).toFixed(2)} MB
+  ${c('cyan', 'Node Target:')} ${nodeWasmExists ? c('green', '✓') : c('red', '✗')} ${(nodeWasmSize / 1024 / 1024).toFixed(2)} MB
 
-${c('bold', 'EXPORTS:')}
-  ${c('cyan', 'Main:')}        ${pkg.main}
-  ${c('cyan', 'Types:')}       ${pkg.types}
-  ${c('cyan', 'CLI:')}         edge-net, ruvector-edge
+${c('bold', 'ENVIRONMENT:')}
+  ${c('cyan', 'Runtime:')}     Node.js ${process.version}
+  ${c('cyan', 'Platform:')}    ${process.platform} ${process.arch}
+  ${c('cyan', 'Crypto:')}      ${typeof globalThis.crypto !== 'undefined' ? c('green', '✓ Available') : c('yellow', '⚠ Polyfilled')}
+
+${c('bold', 'CLI COMMANDS:')}
+  ${c('cyan', 'edge-net')}     Main CLI binary
+  ${c('cyan', 'ruvector-edge')} Alias
 
 ${c('bold', 'CAPABILITIES:')}
   ${c('green', '✓')} Ed25519 digital signatures
@@ -129,51 +192,118 @@ ${c('bold', 'CAPABILITIES:')}
 `);
 }
 
+async function testWasm() {
+  printBanner();
+  console.log(`${c('bold', 'Testing WASM Module Loading...')}\n`);
+
+  // Setup polyfills
+  await setupPolyfills();
+  console.log(`${c('green', '✓')} Polyfills configured\n`);
+
+  try {
+    // Load Node.js WASM module
+    const { createRequire } = await import('module');
+    const require = createRequire(import.meta.url);
+
+    console.log(`${c('cyan', '1. Loading Node.js WASM module...')}`);
+    const wasm = require('./node/ruvector_edge_net.cjs');
+    console.log(`   ${c('green', '✓')} Module loaded\n`);
+
+    console.log(`${c('cyan', '2. Available exports:')}`);
+    const exports = Object.keys(wasm).filter(k => !k.startsWith('__')).slice(0, 15);
+    exports.forEach(e => console.log(`   ${c('dim', '•')} ${e}`));
+    console.log(`   ${c('dim', '...')} and ${Object.keys(wasm).length - 15} more\n`);
+
+    console.log(`${c('cyan', '3. Testing components:')}`);
+
+    // Test ByzantineDetector
+    try {
+      const detector = new wasm.ByzantineDetector(0.5);
+      console.log(`   ${c('green', '✓')} ByzantineDetector - created`);
+    } catch (e) {
+      console.log(`   ${c('red', '✗')} ByzantineDetector - ${e.message}`);
+    }
+
+    // Test FederatedModel
+    try {
+      const model = new wasm.FederatedModel(100, 0.01, 0.9);
+      console.log(`   ${c('green', '✓')} FederatedModel - created`);
+    } catch (e) {
+      console.log(`   ${c('red', '✗')} FederatedModel - ${e.message}`);
+    }
+
+    // Test DifferentialPrivacy
+    try {
+      const dp = new wasm.DifferentialPrivacy(1.0, 0.001);
+      console.log(`   ${c('green', '✓')} DifferentialPrivacy - created`);
+    } catch (e) {
+      console.log(`   ${c('red', '✗')} DifferentialPrivacy - ${e.message}`);
+    }
+
+    // Test EdgeNetNode (may need web APIs)
+    try {
+      const node = new wasm.EdgeNetNode();
+      console.log(`   ${c('green', '✓')} EdgeNetNode - created`);
+      console.log(`      ${c('dim', 'Node ID:')} ${node.nodeId().substring(0, 32)}...`);
+    } catch (e) {
+      console.log(`   ${c('yellow', '⚠')} EdgeNetNode - ${e.message.substring(0, 50)}...`);
+      console.log(`      ${c('dim', 'Note: Some features require browser environment')}`);
+    }
+
+    console.log(`\n${c('green', '✓ WASM module test complete!')}`);
+
+  } catch (err) {
+    console.error(`${c('red', '✗ Failed to load WASM:')}\n`, err.message);
+  }
+}
+
 async function runBenchmark() {
   printBanner();
   console.log(`${c('bold', 'Running Performance Benchmarks...')}\n`);
 
-  // Dynamic import for Node.js WASM support
+  await setupPolyfills();
+
   try {
-    const wasm = await import('./ruvector_edge_net.js');
-    await wasm.default();
-
-    console.log(`${c('green', '✓')} WASM module loaded successfully\n`);
-
-    // Benchmark: Node creation
-    console.log(`${c('cyan', '1. Node Identity Creation')}`);
-    const startNode = performance.now();
-    const node = new wasm.EdgeNetNode();
-    const nodeTime = performance.now() - startNode;
-    console.log(`   ${c('dim', 'Time:')} ${nodeTime.toFixed(2)}ms`);
-    console.log(`   ${c('dim', 'Node ID:')} ${node.nodeId().substring(0, 16)}...`);
-
-    // Benchmark: Credit operations
-    console.log(`\n${c('cyan', '2. Credit Operations')}`);
-    const creditStart = performance.now();
-    for (let i = 0; i < 1000; i++) {
-      node.credit(100);
+    const { createRequire } = await import('module');
+    const require = createRequire(import.meta.url);
+    const wasm = require('./node/ruvector_edge_net.cjs');
+
+    console.log(`${c('green', '✓')} WASM module loaded\n`);
+
+    // Benchmark: ByzantineDetector
+    console.log(`${c('cyan', '1. Byzantine Detector')}`);
+    const bzStart = performance.now();
+    for (let i = 0; i < 10000; i++) {
+      const detector = new wasm.ByzantineDetector(0.5);
+      detector.getMaxMagnitude();
+      detector.free();
     }
-    const creditTime = performance.now() - creditStart;
-    console.log(`   ${c('dim', '1000 credits:')} ${creditTime.toFixed(2)}ms`);
-    console.log(`   ${c('dim', 'Balance:')} ${node.balance()} tokens`);
+    console.log(`   ${c('dim', '10k create/query/free:')} ${(performance.now() - bzStart).toFixed(2)}ms`);
 
-    // Benchmark: Statistics
-    console.log(`\n${c('cyan', '3. Node Statistics')}`);
-    const statsStart = performance.now();
-    const stats = node.stats();
-    const statsTime = performance.now() - statsStart;
-    console.log(`   ${c('dim', 'Stats generation:')} ${statsTime.toFixed(2)}ms`);
+    // Benchmark: FederatedModel
+    console.log(`\n${c('cyan', '2. Federated Model')}`);
+    const fmStart = performance.now();
+    for (let i = 0; i < 1000; i++) {
+      const model = new wasm.FederatedModel(100, 0.01, 0.9);
+      model.free();
+    }
+    console.log(`   ${c('dim', '1k model create/free:')} ${(performance.now() - fmStart).toFixed(2)}ms`);
 
-    const parsedStats = JSON.parse(stats);
-    console.log(`   ${c('dim', 'Total credits:')} ${parsedStats.credits_earned || 0}`);
+    // Benchmark: DifferentialPrivacy
+    console.log(`\n${c('cyan', '3. Differential Privacy')}`);
+    const dpStart = performance.now();
+    for (let i = 0; i < 1000; i++) {
+      const dp = new wasm.DifferentialPrivacy(1.0, 0.001);
+      dp.getEpsilon();
+      dp.isEnabled();
+      dp.free();
+    }
+    console.log(`   ${c('dim', '1k DP operations:')} ${(performance.now() - dpStart).toFixed(2)}ms`);
 
-    console.log(`\n${c('green', '✓ All benchmarks completed successfully!')}\n`);
+    console.log(`\n${c('green', '✓ Benchmarks complete!')}`);
 
   } catch (err) {
     console.error(`${c('red', '✗ Benchmark failed:')}\n`, err.message);
-    console.log(`\n${c('yellow', 'Note:')} Node.js WASM support requires specific setup.`);
-    console.log(`${c('dim', 'For full functionality, use in a browser environment.')}`);
   }
 }
 
@@ -181,35 +311,48 @@ async function startNode() {
   printBanner();
   console.log(`${c('bold', 'Starting Edge-Net Node...')}\n`);
 
-  try {
-    const wasm = await import('./ruvector_edge_net.js');
-    await wasm.default();
+  await setupPolyfills();
 
-    const node = new wasm.EdgeNetNode();
-
-    console.log(`${c('green', '✓')} Node started successfully!`);
-    console.log(`\n${c('bold', 'NODE INFO:')}`);
-    console.log(`  ${c('cyan', 'ID:')}      ${node.nodeId()}`);
-    console.log(`  ${c('cyan', 'Balance:')} ${node.balance()} tokens`);
-    console.log(`  ${c('cyan', 'Status:')}  ${c('green', 'Active')}`);
+  try {
+    const { createRequire } = await import('module');
+    const require = createRequire(import.meta.url);
+    const wasm = require('./node/ruvector_edge_net.cjs');
+
+    // Try to create EdgeNetNode
+    let node;
+    try {
+      node = new wasm.EdgeNetNode();
+      console.log(`${c('green', '✓')} Full node started`);
+      console.log(`\n${c('bold', 'NODE INFO:')}`);
+      console.log(`  ${c('cyan', 'ID:')}      ${node.nodeId()}`);
+      console.log(`  ${c('cyan', 'Balance:')} ${node.balance()} tokens`);
+    } catch (e) {
+      // Fall back to lightweight mode
+      console.log(`${c('yellow', '⚠')} Full node unavailable in CLI (needs browser)`);
+      console.log(`${c('green', '✓')} Starting in lightweight mode\n`);
+
+      const detector = new wasm.ByzantineDetector(0.5);
+      const dp = new wasm.DifferentialPrivacy(1.0, 0.001);
+
+      console.log(`${c('bold', 'LIGHTWEIGHT NODE:')}`);
+      console.log(`  ${c('cyan', 'Byzantine Detector:')} Active`);
+      console.log(`  ${c('cyan', 'Differential Privacy:')} ε=1.0, δ=0.001`);
+      console.log(`  ${c('cyan', 'Mode:')} AI Components Only`);
+    }
 
-    console.log(`\n${c('dim', 'Press Ctrl+C to stop the node.')}`);
+    console.log(`  ${c('cyan', 'Status:')}  ${c('green', 'Running')}`);
+    console.log(`\n${c('dim', 'Press Ctrl+C to stop.')}`);
 
-    // Keep the process running
+    // Keep running
     process.on('SIGINT', () => {
-      console.log(`\n${c('yellow', 'Shutting down node...')}`);
+      console.log(`\n${c('yellow', 'Node stopped.')}`);
       process.exit(0);
     });
 
-    // Heartbeat
-    setInterval(() => {
-      node.credit(1); // Simulate earning
-    }, 5000);
+    setInterval(() => {}, 1000);
 
   } catch (err) {
-    console.error(`${c('red', '✗ Failed to start node:')}\n`, err.message);
-    console.log(`\n${c('yellow', 'Note:')} Node.js WASM requires web environment features.`);
-    console.log(`${c('dim', 'Consider using: node --experimental-wasm-modules')}`);
+    console.error(`${c('red', '✗ Failed to start:')}\n`, err.message);
   }
 }
 
@@ -217,45 +360,78 @@ async function runDemo() {
   printBanner();
   console.log(`${c('bold', 'Running Interactive Demo...')}\n`);
 
-  console.log(`${c('cyan', 'Step 1:')} Creating edge-net node identity...`);
-  console.log(`  ${c('dim', '→ Generating Ed25519 keypair')}`);
-  console.log(`  ${c('dim', '→ Deriving X25519 DH key')}`);
-  console.log(`  ${c('green', '✓')} Identity created\n`);
-
-  console.log(`${c('cyan', 'Step 2:')} Initializing AI capabilities...`);
-  console.log(`  ${c('dim', '→ Time Crystal coordinator (8 oscillators)')}`);
-  console.log(`  ${c('dim', '→ DAG attention engine')}`);
-  console.log(`  ${c('dim', '→ HNSW vector index (128-dim)')}`);
-  console.log(`  ${c('green', '✓')} AI layer initialized\n`);
-
-  console.log(`${c('cyan', 'Step 3:')} Connecting to P2P network...`);
-  console.log(`  ${c('dim', '→ Gossipsub pubsub')}`);
-  console.log(`  ${c('dim', '→ Semantic routing')}`);
-  console.log(`  ${c('dim', '→ Swarm discovery')}`);
-  console.log(`  ${c('green', '✓')} Network ready\n`);
-
-  console.log(`${c('cyan', 'Step 4:')} Joining compute marketplace...`);
-  console.log(`  ${c('dim', '→ Registering compute capabilities')}`);
-  console.log(`  ${c('dim', '→ Setting credit rate')}`);
-  console.log(`  ${c('dim', '→ Listening for tasks')}`);
-  console.log(`  ${c('green', '✓')} Marketplace joined\n`);
-
-  console.log(`${c('bold', '─────────────────────────────────────────────────')}`);
-  console.log(`${c('green', '✓ Demo complete!')} Node is ready to contribute compute.\n`);
-  console.log(`${c('dim', 'In production, the node would now:')}`);
-  console.log(`  • Accept compute tasks from the network`);
-  console.log(`  • Execute WASM workloads in isolated sandboxes`);
-  console.log(`  • Earn credits for contributed compute`);
-  console.log(`  • Participate in swarm coordination`);
+  await setupPolyfills();
+
+  const delay = (ms) => new Promise(r => setTimeout(r, ms));
+
+  console.log(`${c('cyan', 'Step 1:')} Loading WASM module...`);
+  await delay(200);
+  console.log(`  ${c('green', '✓')} Module loaded (1.13 MB)\n`);
+
+  console.log(`${c('cyan', 'Step 2:')} Initializing AI components...`);
+  await delay(150);
+  console.log(`  ${c('dim', '→')} Byzantine fault detector`);
+  console.log(`  ${c('dim', '→')} Differential privacy engine`);
+  console.log(`  ${c('dim', '→')} Federated learning model`);
+  console.log(`  ${c('green', '✓')} AI layer ready\n`);
+
+  console.log(`${c('cyan', 'Step 3:')} Testing components...`);
+  await delay(100);
+
+  try {
+    const { createRequire } = await import('module');
+    const require = createRequire(import.meta.url);
+    const wasm = require('./node/ruvector_edge_net.cjs');
+
+    const detector = new wasm.ByzantineDetector(0.5);
+    const dp = new wasm.DifferentialPrivacy(1.0, 0.001);
+    const model = new wasm.FederatedModel(100, 0.01, 0.9);
+
+    console.log(`  ${c('green', '✓')} ByzantineDetector: threshold=0.5`);
+    console.log(`  ${c('green', '✓')} DifferentialPrivacy: ε=1.0, δ=0.001`);
+    console.log(`  ${c('green', '✓')} FederatedModel: dim=100, lr=0.01\n`);
+
+    console.log(`${c('cyan', 'Step 4:')} Running simulation...`);
+    await delay(200);
+
+    // Simulate some operations using available methods
+    for (let i = 0; i < 5; i++) {
+      const maxMag = detector.getMaxMagnitude();
+      const epsilon = dp.getEpsilon();
+      const enabled = dp.isEnabled();
+      console.log(`  ${c('dim', `Round ${i + 1}:`)} maxMag=${maxMag.toFixed(2)}, ε=${epsilon.toFixed(2)}, enabled=${enabled}`);
+      await delay(100);
+    }
+
+  } catch (e) {
+    console.log(`  ${c('yellow', '⚠')} Some components unavailable: ${e.message}`);
+  }
+
+  console.log(`\n${c('bold', '─────────────────────────────────────────────────')}`);
+  console.log(`${c('green', '✓ Demo complete!')} WASM module is functional.\n`);
+  console.log(`${c('dim', 'For full P2P features, run in a browser environment.')}`);
 }
 
-// Main CLI handler
+async function runJoin() {
+  // Delegate to join.js
+  const { spawn } = await import('child_process');
+  const args = process.argv.slice(3);
+  const child = spawn('node', [join(__dirname, 'join.js'), ...args], {
+    stdio: 'inherit'
+  });
+  child.on('close', (code) => process.exit(code));
+}
+
+// Main
 const command = process.argv[2] || 'help';
 
 switch (command) {
   case 'start':
     startNode();
     break;
+  case 'join':
+    runJoin();
+    break;
   case 'benchmark':
   case 'bench':
     runBenchmark();
@@ -266,6 +442,9 @@ switch (command) {
   case 'demo':
     runDemo();
     break;
+  case 'test':
+    testWasm();
+    break;
   case 'help':
   case '--help':
   case '-h':