@bitcall/pm2-pulse-agent 1.0.1-beta.0

package/README.md

@@ -0,0 +1 @@
+# MONITORING-SERVICE

package/agent.js

@@ -0,0 +1,179 @@
+const os = require('os')
+const { exec } = require('child_process')
+const grpc = require('@grpc/grpc-js')
+const protoLoader = require('@grpc/proto-loader')
+require('dotenv').config()
+
+// Fixed agent defaults (only token + thresholds are configurable)
+const DEFAULT_SERVER = 'localhost:50051'
+const DEFAULT_VPS_ID = 'server-' + os.hostname()
+const DEFAULT_CHECK_INTERVAL = 10 // seconds (accurate CPU measurement)
+const DEFAULT_CPU_THRESHOLD = 70
+const DEFAULT_RAM_THRESHOLD = 80
+const DEFAULT_AUTH_TOKEN = process.env.AUTH_TOKEN || ''
+
+class MonitoringAgent {
+  static instance = null
+
+  static getInstance() {
+    if (!MonitoringAgent.instance) {
+      MonitoringAgent.instance = new MonitoringAgent()
+    }
+    return MonitoringAgent.instance
+  }
+
+  constructor() {
+    if (MonitoringAgent.instance) {
+      throw new Error('MonitoringAgent is a singleton. Use MonitoringAgent.getInstance().')
+    }
+
+    this.server = process.env.MONITOR_SERVER || DEFAULT_SERVER
+    this.vpsId = process.env.VPS_ID || DEFAULT_VPS_ID
+    this.checkInterval = DEFAULT_CHECK_INTERVAL
+    this.authToken = DEFAULT_AUTH_TOKEN
+    this.cpuThreshold = parseInt(process.env.CPU_THRESHOLD, 10) || DEFAULT_CPU_THRESHOLD
+    this.ramThreshold = parseInt(process.env.RAM_THRESHOLD, 10) || DEFAULT_RAM_THRESHOLD
+
+    const credentials = grpc.credentials.createInsecure()
+    this.client = new proto.MonitoringService(this.server, credentials)
+  }
+
+  getCpu() {
+    return new Promise(resolve => {
+      const startSnapshot = os.cpus()
+      const startTotals = startSnapshot.map(c => Object.values(c.times).reduce((a, b) => a + b))
+      const startIdle = startSnapshot.reduce((acc, c) => acc + c.times.idle, 0)
+
+      // Wait 2 seconds for accurate measurement
+      setTimeout(() => {
+        const endSnapshot = os.cpus()
+        const endTotals = endSnapshot.map(c => Object.values(c.times).reduce((a, b) => a + b))
+        const endIdle = endSnapshot.reduce((acc, c) => acc + c.times.idle, 0)
+
+        const totalStart = startTotals.reduce((a, b) => a + b, 0)
+        const totalEnd = endTotals.reduce((a, b) => a + b, 0)
+
+        const idleDiff = endIdle - startIdle
+        const totalDiff = totalEnd - totalStart
+
+        const usage = totalDiff > 0 ? 100 - (100 * idleDiff) / totalDiff : 0
+        resolve(Math.max(0, Math.min(100, Math.round(usage))))
+      }, 2000)
+    })
+  }
+
+  getRamStats() {
+    const totalBytes = os.totalmem()
+    const freeBytes = os.freemem()
+    const usedBytes = Math.max(0, totalBytes - freeBytes)
+    const percent = totalBytes > 0 ? Math.round((usedBytes / totalBytes) * 100) : 0
+    return {
+      percent,
+      usedMb: Math.round(usedBytes / 1024 / 1024),
+      totalMb: Math.round(totalBytes / 1024 / 1024)
+    }
+  }
+
+  getPm2() {
+    return new Promise(resolve => {
+      exec('pm2 jlist', (err, stdout) => {
+        if (err) return resolve([])
+        const list = JSON.parse(stdout)
+        resolve(
+          list.map(p => ({
+            name: p.name,
+            status: p.pm2_env?.status || 'unknown',
+            restarts: p.pm2_env?.restart_time || 0,
+            cpu_percent: p.monit?.cpu || 0,
+            memory_mb: p.monit?.memory ? Math.round(p.monit.memory / 1024 / 1024) : 0
+          }))
+        )
+      })
+    })
+  }
+
+  async sendMetrics(isUrgent = false) {
+    const cpu = await this.getCpu()
+    const ramStats = this.getRamStats()
+    const ramPercent = ramStats.percent
+    const processes = await this.getPm2()
+
+    const alerts = []
+    if (cpu > this.cpuThreshold) alerts.push(`High CPU: ${cpu}%`)
+    if (ramPercent > this.ramThreshold) alerts.push(`High RAM: ${ramPercent}%`)
+    processes.forEach(p => {
+      if (p.status !== 'online') alerts.push(`${p.name} is ${p.status}`)
+    })
+
+    const hasAlerts = alerts.length > 0
+    console.log(
+      `[${new Date().toLocaleTimeString()}] CPU: ${cpu}% | RAM: ${ramStats.usedMb}/${ramStats.totalMb}MB (${ramPercent}%) | Alerts: ${alerts.length}${
+        hasAlerts ? ' 🚨' : ''
+      }`
+    )
+
+    const metricsMessage = {
+      vps_id: this.vpsId,
+      cpu,
+      ram: ramPercent,
+      ram_used_mb: ramStats.usedMb,
+      ram_total_mb: ramStats.totalMb,
+      processes,
+      alerts,
+      urgent: isUrgent || hasAlerts,
+      timestamp: Date.now()
+    }
+
+    console.log('DEBUG - Sending message:', JSON.stringify(metricsMessage, null, 2))
+
+    // Add auth token to metadata if configured
+    const metadata = new grpc.Metadata()
+    if (this.authToken) {
+      metadata.add('authorization', `Bearer ${this.authToken}`)
+    }
+
+    this.client.SendMetrics(metricsMessage, metadata, (err, response) => {
+      if (err) console.error('Error:', err.message)
+      else if (hasAlerts) console.log('✓ Alert sent to server')
+    })
+  }
+
+  start() {
+    const intervalSeconds = parseInt(this.checkInterval, 10)
+    console.log('='.repeat(60))
+    console.log('🚀 PM2 Monitoring Agent Started')
+    console.log('='.repeat(60))
+    console.log(`VPS ID: ${this.vpsId}`)
+    console.log(`Server: ${this.server}`)
+    console.log(`Authentication: ${this.authToken ? '✓ Enabled' : '✗ Disabled'}`)
+    console.log(`Check interval: ${intervalSeconds} second(s)`)
+    console.log(`CPU Threshold: ${this.cpuThreshold}%`)
+    console.log(`RAM Threshold: ${this.ramThreshold}%`)
+    console.log('='.repeat(60) + '\n')
+
+    // Run once on start
+    this.sendMetrics()
+
+    // Then run on interval
+    setInterval(async () => {
+      await this.sendMetrics()
+    }, intervalSeconds * 1000)
+  }
+}
+
+// Load proto
+const proto = grpc.loadPackageDefinition(
+  protoLoader.loadSync('monitoring.proto', {
+    keepCase: true,
+    longs: String,
+    enums: String,
+    defaults: true,
+    oneofs: true
+  })
+).monitoring
+
+module.exports = MonitoringAgent
+
+if (require.main === module) {
+  MonitoringAgent.getInstance().start()
+}

package/monitoring.proto

@@ -0,0 +1,32 @@
+syntax = "proto3";
+
+package monitoring;
+
+service MonitoringService {
+  rpc SendMetrics(MetricsData) returns (Response);
+}
+
+message MetricsData {
+  string vps_id = 1;
+  double cpu = 2;
+  double ram = 3;
+  double ram_used_mb = 8;
+  double ram_total_mb = 9;
+  repeated Process processes = 4;
+  repeated string alerts = 5;
+  bool urgent = 6;
+  int64 timestamp = 7;
+}
+
+message Process {
+  string name = 1;
+  string status = 2;
+  int32 restarts = 3;
+  double cpu_percent = 4;
+  int64 memory_mb = 5;
+}
+
+message Response {
+  bool success = 1;
+  string message = 2;
+}

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@bitcall/pm2-pulse-agent",
+  "version": "1.0.1-beta.0",
+  "scripts": {
+    "agent": "node agent.js",
+    "monitor": "node agent.js",
+    "setup-agent": "node scripts/setup-agent.js"
+  },
+  "dependencies": {
+    "@grpc/grpc-js": "^1.10.1",
+    "@grpc/proto-loader": "^0.7.10",
+    "dotenv": "^17.2.3"
+  }
+}

package/scripts/setup-agent.js

@@ -0,0 +1,72 @@
+const fs = require('fs')
+const path = require('path')
+const readline = require('readline')
+
+const envPath = path.join(process.cwd(), '.env')
+
+function loadEnvFile() {
+  if (!fs.existsSync(envPath)) return []
+  return fs.readFileSync(envPath, 'utf8').split(/\r?\n/)
+}
+
+function getEnvValue(lines, key) {
+  const prefix = `${key}=`
+  const line = lines.find(l => l.startsWith(prefix))
+  if (!line) return ''
+  return line.slice(prefix.length)
+}
+
+function upsertEnvValue(lines, key, value) {
+  const prefix = `${key}=`
+  const idx = lines.findIndex(l => l.startsWith(prefix))
+  const line = `${key}=${value}`
+  if (idx === -1) {
+    lines.push(line)
+  } else {
+    lines[idx] = line
+  }
+}
+
+function askQuestion(rl, prompt) {
+  return new Promise(resolve => {
+    rl.question(prompt, answer => resolve(answer.trim()))
+  })
+}
+
+async function run() {
+  const lines = loadEnvFile()
+  const currentToken = getEnvValue(lines, 'AUTH_TOKEN')
+  const currentServer = getEnvValue(lines, 'MONITOR_SERVER') || 'localhost:50051'
+  const currentVpsId = getEnvValue(lines, 'VPS_ID') || `server-${require('os').hostname()}`
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  })
+
+  const tokenPrompt = `Secret token (AUTH_TOKEN) [${currentToken ? 'set' : 'empty'}]: `
+  const serverPrompt = `Monitor server (MONITOR_SERVER) [${currentServer}]: `
+  const vpsPrompt = `Default VPS ID (VPS_ID) [${currentVpsId}]: `
+
+  const tokenInput = await askQuestion(rl, tokenPrompt)
+  const serverInput = await askQuestion(rl, serverPrompt)
+  const vpsInput = await askQuestion(rl, vpsPrompt)
+
+  rl.close()
+
+  const finalToken = tokenInput !== '' ? tokenInput : currentToken
+  const finalServer = serverInput !== '' ? serverInput : currentServer
+  const finalVpsId = vpsInput !== '' ? vpsInput : currentVpsId
+
+  upsertEnvValue(lines, 'AUTH_TOKEN', finalToken)
+  upsertEnvValue(lines, 'MONITOR_SERVER', finalServer)
+  upsertEnvValue(lines, 'VPS_ID', finalVpsId)
+
+  fs.writeFileSync(envPath, lines.join('\n'))
+  console.log(`Saved: ${envPath}`)
+}
+
+run().catch(err => {
+  console.error('Setup failed:', err.message)
+  process.exit(1)
+})