@ruvector/edge-net 0.4.2 → 0.4.4

package/deploy/health-check.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+/**
+ * @ruvector/edge-net Genesis Node Health Check
+ *
+ * Standalone health check script for use with container orchestrators,
+ * load balancers, and monitoring systems.
+ *
+ * Usage:
+ *   node deploy/health-check.js                    # Check localhost:8788
+ *   node deploy/health-check.js --host 10.0.0.1   # Check specific host
+ *   node deploy/health-check.js --port 9000       # Check specific port
+ *   node deploy/health-check.js --endpoint ready  # Check readiness
+ *   node deploy/health-check.js --json            # JSON output
+ *
+ * Exit codes:
+ *   0 - Healthy
+ *   1 - Unhealthy or error
+ *
+ * @module @ruvector/edge-net/deploy/health-check
+ */
+
+import http from 'http';
+
+// Parse arguments
+const args = process.argv.slice(2);
+const config = {
+    host: 'localhost',
+    port: 8788,
+    endpoint: 'health',
+    timeout: 5000,
+    json: false,
+};
+
+for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+        case '--host':
+        case '-h':
+            config.host = args[++i];
+            break;
+        case '--port':
+        case '-p':
+            config.port = parseInt(args[++i]);
+            break;
+        case '--endpoint':
+        case '-e':
+            config.endpoint = args[++i];
+            break;
+        case '--timeout':
+        case '-t':
+            config.timeout = parseInt(args[++i]);
+            break;
+        case '--json':
+        case '-j':
+            config.json = true;
+            break;
+        case '--help':
+            console.log(`
+Genesis Node Health Check
+
+Usage: node health-check.js [options]
+
+Options:
+  --host, -h <host>       Host to check (default: localhost)
+  --port, -p <port>       Port to check (default: 8788)
+  --endpoint, -e <path>   Endpoint to check: health, ready, status, metrics (default: health)
+  --timeout, -t <ms>      Request timeout in milliseconds (default: 5000)
+  --json, -j              Output JSON format
+  --help                  Show this help
+
+Examples:
+  node health-check.js
+  node health-check.js --host genesis.example.com --port 8788
+  node health-check.js --endpoint ready
+  node health-check.js --json
+
+Exit Codes:
+  0 - Healthy/Ready
+  1 - Unhealthy/Not Ready/Error
+`);
+            process.exit(0);
+    }
+}
+
+function checkHealth() {
+    return new Promise((resolve, reject) => {
+        const startTime = Date.now();
+
+        const req = http.get({
+            hostname: config.host,
+            port: config.port,
+            path: `/${config.endpoint}`,
+            timeout: config.timeout,
+        }, (res) => {
+            let data = '';
+
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                const latency = Date.now() - startTime;
+
+                try {
+                    const parsed = JSON.parse(data);
+                    resolve({
+                        healthy: res.statusCode === 200,
+                        statusCode: res.statusCode,
+                        latency,
+                        data: parsed,
+                    });
+                } catch {
+                    resolve({
+                        healthy: res.statusCode === 200,
+                        statusCode: res.statusCode,
+                        latency,
+                        data: data,
+                    });
+                }
+            });
+        });
+
+        req.on('error', (err) => {
+            reject({
+                healthy: false,
+                error: err.message,
+                latency: Date.now() - startTime,
+            });
+        });
+
+        req.on('timeout', () => {
+            req.destroy();
+            reject({
+                healthy: false,
+                error: 'Request timeout',
+                latency: config.timeout,
+            });
+        });
+    });
+}
+
+async function main() {
+    try {
+        const result = await checkHealth();
+
+        if (config.json) {
+            console.log(JSON.stringify({
+                ...result,
+                host: config.host,
+                port: config.port,
+                endpoint: config.endpoint,
+                timestamp: new Date().toISOString(),
+            }, null, 2));
+        } else {
+            if (result.healthy) {
+                console.log(`OK - ${config.host}:${config.port}/${config.endpoint} (${result.latency}ms)`);
+
+                if (result.data?.ready !== undefined) {
+                    console.log(`  Ready: ${result.data.ready}`);
+                }
+                if (result.data?.status) {
+                    console.log(`  Status: ${result.data.status}`);
+                }
+            } else {
+                console.log(`FAIL - ${config.host}:${config.port}/${config.endpoint}`);
+                console.log(`  Status Code: ${result.statusCode}`);
+            }
+        }
+
+        process.exit(result.healthy ? 0 : 1);
+
+    } catch (error) {
+        if (config.json) {
+            console.log(JSON.stringify({
+                healthy: false,
+                host: config.host,
+                port: config.port,
+                endpoint: config.endpoint,
+                error: error.error || error.message,
+                timestamp: new Date().toISOString(),
+            }, null, 2));
+        } else {
+            console.log(`ERROR - ${config.host}:${config.port}/${config.endpoint}`);
+            console.log(`  Error: ${error.error || error.message}`);
+        }
+
+        process.exit(1);
+    }
+}
+
+main();

package/deploy/prometheus.yml

@@ -0,0 +1,38 @@
+# Prometheus configuration for Edge-Net Genesis Node monitoring
+#
+# Scrapes metrics from genesis nodes at /metrics endpoint
+
+global:
+  scrape_interval: 15s
+  evaluation_interval: 15s
+  external_labels:
+    cluster: 'edge-net-local'
+
+alerting:
+  alertmanagers: []
+
+rule_files: []
+
+scrape_configs:
+  # Primary Genesis Node
+  - job_name: 'genesis'
+    static_configs:
+      - targets: ['genesis:8788']
+        labels:
+          instance: 'genesis-primary'
+    metrics_path: /metrics
+    scrape_interval: 10s
+
+  # Secondary Genesis Node (if cluster profile enabled)
+  - job_name: 'genesis-cluster'
+    static_configs:
+      - targets: ['genesis-2:8788']
+        labels:
+          instance: 'genesis-secondary'
+    metrics_path: /metrics
+    scrape_interval: 10s
+
+  # Prometheus self-monitoring
+  - job_name: 'prometheus'
+    static_configs:
+      - targets: ['localhost:9090']

package/firebase-signaling.js

@@ -423,6 +423,22 @@ export class FirebaseSignaling extends EventEmitter {
             case 'ice-candidate':
                 this.emit('ice-candidate', { from: signal.from, candidate: signal.data, verified: !!signal.signature });
                 break;
+            // Task execution signal types
+            case 'task-assign':
+            case 'task-result':
+            case 'task-error':
+            case 'task-progress':
+            case 'task-cancel':
+                this.emit('signal', {
+                    type: signal.type,
+                    from: signal.from,
+                    data: signal.data,
+                    verified: !!signal.signature,
+                    signature: signal.signature,
+                    publicKey: signal.publicKey,
+                    timestamp: signal.timestamp,
+                });
+                break;
             default:
                 this.emit('signal', { ...signal, verified: !!signal.signature });
         }
@@ -449,6 +465,42 @@ export class FirebaseSignaling extends EventEmitter {
         return this.sendSignal(toPeerId, 'ice-candidate', candidate);
     }
 
+    /**
+     * Serialize WebRTC objects to plain JSON for Firebase storage
+     * RTCIceCandidate and RTCSessionDescription are not directly storable
+     */
+    _serializeWebRTCData(data) {
+        if (!data || typeof data !== 'object') {
+            return data;
+        }
+
+        // Handle RTCIceCandidate
+        if (data.candidate !== undefined && data.sdpMid !== undefined) {
+            return {
+                candidate: data.candidate,
+                sdpMid: data.sdpMid,
+                sdpMLineIndex: data.sdpMLineIndex,
+                usernameFragment: data.usernameFragment || null,
+            };
+        }
+
+        // Handle RTCSessionDescription (offer/answer)
+        if (data.type !== undefined && data.sdp !== undefined) {
+            return {
+                type: data.type,
+                sdp: data.sdp,
+            };
+        }
+
+        // Try to convert any object with toJSON method
+        if (typeof data.toJSON === 'function') {
+            return data.toJSON();
+        }
+
+        // Return as-is if already plain object
+        return data;
+    }
+
     /**
      * Send signal via Firebase with WASM signature
      */
@@ -462,12 +514,15 @@ export class FirebaseSignaling extends EventEmitter {
         const signalId = `${this.peerId}-${toPeerId}-${Date.now()}`;
         const signalRef = doc(this.db, SIGNALING_PATHS.signals, signalId);
 
+        // Serialize WebRTC objects to plain JSON
+        const serializedData = this._serializeWebRTCData(data);
+
         const timestamp = Date.now();
         const signalData = {
             from: this.peerId,
             to: toPeerId,
             type,
-            data,
+            data: serializedData,
             timestamp,
             room: this.room,
         };
@@ -478,7 +533,7 @@ export class FirebaseSignaling extends EventEmitter {
                 from: this.peerId,
                 to: toPeerId,
                 type,
-                data: typeof data === 'object' ? JSON.stringify(data) : data,
+                data: typeof serializedData === 'object' ? JSON.stringify(serializedData) : serializedData,
                 timestamp
             });
             signalData.signature = signed.signature;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruvector/edge-net",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "type": "module",
   "description": "Distributed compute intelligence network with WASM cryptographic security - contribute browser compute, spawn distributed AI agents, earn credits. Features Ed25519 signing, PiKey identity, Time Crystal coordination, Neural DAG attention, P2P swarm intelligence, ONNX inference, WebRTC signaling, CRDT ledger, and multi-agent workflows.",
   "main": "ruvector_edge_net.js",
@@ -77,6 +77,8 @@
     "ruvector_edge_net.d.ts",
     "ruvector_edge_net_bg.wasm.d.ts",
     "node/",
+    "deploy/",
+    "tests/",
     "index.js",
     "cli.js",
     "join.js",
@@ -189,6 +191,11 @@
     "signaling": "node -e \"import('./signaling.js').then(m => new m.SignalingServer().start())\"",
     "genesis": "node genesis.js",
     "genesis:start": "node genesis.js --port 8787",
+    "genesis:prod": "NODE_ENV=production node deploy/genesis-prod.js",
+    "genesis:docker": "docker-compose -f deploy/docker-compose.yml up -d",
+    "genesis:docker:logs": "docker-compose -f deploy/docker-compose.yml logs -f genesis",
+    "genesis:docker:stop": "docker-compose -f deploy/docker-compose.yml down",
+    "genesis:docker:build": "docker build -t ruvector/edge-net-genesis:latest -f deploy/Dockerfile .",
     "p2p": "node -e \"import('./p2p.js').then(m => m.createP2PNetwork({ nodeId: 'test' }))\"",
     "monitor": "node -e \"import('./monitor.js').then(m => { const mon = new m.Monitor(); mon.start(); setInterval(() => console.log(JSON.stringify(mon.generateReport(), null, 2)), 5000); })\"",
     "firebase:setup": "node firebase-setup.js",

package/real-workers.js

@@ -295,6 +295,7 @@ export class RealWorkerPool extends EventEmitter {
                     status: 'idle',
                     tasksCompleted: 0,
                     currentTask: null,
+                    terminated: false,  // Track intentional termination
                 };
 
                 worker.on('message', (msg) => {
@@ -307,13 +308,16 @@ export class RealWorkerPool extends EventEmitter {
                 });
 
                 worker.on('exit', (code) => {
-                    if (code !== 0) {
-                        console.error(`[Worker ${index}] Exited with code ${code}`);
+                    // Only respawn if worker crashed unexpectedly (not terminated intentionally)
+                    if (!workerInfo.terminated && this.status === 'ready') {
+                        console.error(`[Worker ${index}] Exited unexpectedly with code ${code}, respawning...`);
                         // Respawn worker
                         const idx = this.workers.indexOf(workerInfo);
-                        if (idx >= 0 && this.status === 'ready') {
+                        if (idx >= 0) {
                             this.spawnWorker(index).then(w => {
                                 this.workers[idx] = w;
+                            }).catch(err => {
+                                console.error(`[Worker ${index}] Failed to respawn:`, err.message);
                             });
                         }
                     }
@@ -537,8 +541,9 @@ export class RealWorkerPool extends EventEmitter {
             await new Promise(r => setTimeout(r, 100));
         }
 
-        // Terminate workers
+        // Terminate workers (mark as intentionally terminated first)
         for (const workerInfo of this.workers) {
+            workerInfo.terminated = true;
             await workerInfo.worker.terminate();
         }
 

package/scheduler.js

@@ -596,11 +596,15 @@ export class TaskScheduler extends EventEmitter {
         worker.allocate(task);
         this.running.set(task.id, task);
 
-        // Calculate wait time
+        // Calculate wait time using running average
         const waitTime = task.startedAt - task.queuedAt;
-        this.stats.avgWaitTime =
-            (this.stats.avgWaitTime * this.stats.submitted + waitTime) /
-            (this.stats.submitted + 1);
+        const assignedCount = this.stats.completed + this.running.size;
+        if (assignedCount <= 1) {
+            this.stats.avgWaitTime = waitTime;
+        } else {
+            this.stats.avgWaitTime =
+                (this.stats.avgWaitTime * (assignedCount - 1) + waitTime) / assignedCount;
+        }
 
         this.emit('task-assigned', {
             taskId: task.id,