Create cpu.js

cpu.js

@@ -0,0 +1,213 @@
+const express = require('express');
+const WebSocket = require('ws');
+const os = require('os');
+const app = express();
+
+app.use(express.json({ limit: '10mb' }));
+
+// Real CPU + System Metrics
+function getCpuMetrics() {
+  const cpus = os.cpus();
+  const totalLoad = cpus.reduce((sum, cpu) => {
+    const total = Object.values(cpu.times).reduce((a, b) => a + b, 0);
+    const idle = cpu.times.idle;
+    return sum + (1 - idle / total);
+  }, 0) / cpus.length;
+  
+  return {
+    id: process.env.WORKER_ID || 'cpu1',
+    hostname: os.hostname(),
+    totalMemory: Math.round(os.totalmem() / 1024 / 1024) + 'MB',
+    freeMemory: Math.round(os.freemem() / 1024 / 1024) + 'MB',
+    memoryUsage: Math.round((os.totalmem() - os.freemem()) / os.totalmem() * 100) + '%',
+    cpuCount: cpus.length,
+    cpuLoad: Math.round(totalLoad * 100),
+    uptime: Math.round(process.uptime() / 60) + 'min',
+    nodeVersion: process.version,
+    timestamp: Date.now()
+  };
+}
+
+// Broker connection
+let broker = null;
+let taskQueue = [];
+let currentTask = null;
+let lastHeartbeat = Date.now();
+
+function connectBroker() {
+  const brokerHost = process.env.BROKER_HOST || 'wss://choruyt-broker-exocore.hf.space';
+  broker = new WebSocket(brokerHost);
+  
+  broker.on('open', () => {
+    console.log(`✅ Broker connected - Worker ${getCpuMetrics().id}`);
+    broker.send(JSON.stringify({ 
+      type: 'register', 
+      role: 'cpu_worker',
+      metrics: getCpuMetrics()
+    }));
+  });
+  
+  broker.on('message', async (data) => {
+    const msg = JSON.parse(data.toString());
+    
+    if (msg.type === 'cpu_task') {
+      if (!currentTask) {
+        currentTask = msg;
+        const result = await executeCpuTask(msg.task);
+        
+        if (broker.readyState === WebSocket.OPEN) {
+          broker.send(JSON.stringify({
+            type: 'cpu_result',
+            taskId: msg.task.id,
+            result,
+            from: getCpuMetrics().id,
+            metrics: getCpuMetrics()
+          }));
+        }
+        
+        currentTask = null;
+        processTaskQueue();
+      } else {
+        taskQueue.push(msg);
+      }
+    }
+  });
+  
+  broker.on('close', () => {
+    console.log('🔌 Broker disconnected, reconnecting...');
+    setTimeout(connectBroker, 3000);
+  });
+
+  broker.on('error', (err) => {
+    console.log('Broker error:', err.message);
+  });
+}
+
+async function executeCpuTask(task) {
+  const startTime = Date.now();
+  
+  try {
+    switch(task.type) {
+      case 'preprocess':
+        // Real tokenization + analysis
+        const tokens = tokenize(task.data);
+        const wordCount = task.data.split(/\s+/).length;
+        const charCount = task.data.length;
+        
+        // CPU-intensive batch processing (non-blocking)
+        await cpuIntensiveWork(1000); // Simulate 1s CPU work
+        
+        return {
+          cpuBoost: true,
+          metrics: getCpuMetrics(),
+          task: 'preprocess',
+          tokens,
+          wordCount,
+          charCount,
+          estimatedPromptTokens: Math.round(tokens * 1.3), // Rough embedding estimate
+          time: Date.now() - startTime
+        };
+        
+      case 'embedding':
+        const vector = generateMockEmbedding(task.data);
+        await cpuIntensiveWork(2000);
+        return { 
+          cpuBoost: true, 
+          dim: vector.length, 
+          time: Date.now() - startTime 
+        };
+        
+      default:
+        await cpuIntensiveWork(500);
+        return { 
+          cpuBoost: true, 
+          message: `Completed ${task.type}`, 
+          time: Date.now() - startTime 
+        };
+    }
+  } catch (e) {
+    return { cpuBoost: false, error: e.message, time: Date.now() - startTime };
+  }
+}
+
+// CPU work simulation (uses real CPU)
+function cpuIntensiveWork(iterations) {
+  return new Promise(resolve => {
+    let i = 0;
+    function work() {
+      for (let j = 0; j < 10000; j++) {
+        Math.sqrt(Math.random() * iterations);
+      }
+      i++;
+      if (i < iterations / 10000) {
+        setImmediate(work);
+      } else {
+        resolve();
+      }
+    }
+    work();
+  });
+}
+
+// Simple tokenizer
+function tokenize(text) {
+  return text.match(/[\w\d\s\u4e00-\u9fff\uac00-\ud7af]+/gi)?.length || 0;
+}
+
+function generateMockEmbedding(text) {
+  const hash = Array.from(text).reduce((a, c) => a + c.charCodeAt(0), 0);
+  return new Array(384).fill(0).map((_, i) => 
+    Math.sin(hash + i) * 0.1 + Math.random() * 0.1
+  );
+}
+
+function processTaskQueue() {
+  if (taskQueue.length > 0 && !currentTask && broker?.readyState === WebSocket.OPEN) {
+    const nextTask = taskQueue.shift();
+    broker.send(JSON.stringify(nextTask));
+  }
+}
+
+// Health endpoints
+app.get('/', (req, res) => {
+  const metrics = getCpuMetrics();
+  res.json({
+    status: 'CPU Worker Active',
+    workerId: metrics.id,
+    ...metrics,
+    queueLength: taskQueue.length,
+    busy: !!currentTask,
+    connected: broker?.readyState === WebSocket.OPEN
+  });
+});
+
+app.get('/health', (req, res) => {
+  res.json({ 
+    status: 'ok',
+    cpuLoad: getCpuMetrics().cpuLoad,
+    memoryUsage: getCpuMetrics().memoryUsage
+  });
+});
+
+// Heartbeat
+setInterval(() => {
+  if (broker?.readyState === WebSocket.OPEN) {
+    broker.send(JSON.stringify({ 
+      type: 'heartbeat', 
+      metrics: getCpuMetrics() 
+    }));
+  }
+}, 30000);
+
+// Startup
+connectBroker();
+
+const server = app.listen(7860, () => {
+  console.log(`🚀 CPU Worker ${getCpuMetrics().id} ready on port 7860`);
+});
+
+process.on('SIGTERM', () => {
+  console.log('Shutting down...');
+  if (broker) broker.close();
+  server.close(() => process.exit(0));
+});