meshcentral-webhook-monitor.js

Go to the documentation of this file.

#!/usr/bin/env node
/**
 * MeshCentral Webhook Monitor
 * 
 * Monitors MeshCentral for device events and sends webhooks to the backend.
 * This is an alternative to the MeshCentral plugin approach.
 * 
 * Usage:
 *   node meshcentral-webhook-monitor.js
 * 
 * Environment Variables:
 *   MESHCENTRAL_URL - MeshCentral server URL
 *   MESHCENTRAL_ADMIN_USER - Admin username
 *   MESHCENTRAL_ADMIN_PASS - Admin password
 *   MESHCENTRAL_WEBHOOK_SECRET - Secret for webhook authentication
 *   BACKEND_URL - Backend API URL
 */
 
const https = require('https');
const http = require('http');
const MeshCentralAPI = require('../lib/meshcentral-api');
 
const MESHCENTRAL_URL = process.env.MESHCENTRAL_URL || 'https://rmm-psa-meshcentral-aq48h.ondigitalocean.app';
const MESHCENTRAL_USER = process.env.MESHCENTRAL_ADMIN_USER || 'admin';
const MESHCENTRAL_PASS = process.env.MESHCENTRAL_ADMIN_PASS || 'admin';
const WEBHOOK_SECRET = process.env.MESHCENTRAL_WEBHOOK_SECRET || '';
const BACKEND_URL = process.env.BACKEND_URL || 'https://everydaytech.au';
const WEBHOOK_PATH = '/api/webhooks/meshcentral';
 
// Track device connection states
const deviceStates = new Map();
 
/**
 * Send webhook to backend
 * @param event
 * @param nodeData
 */
async function sendWebhook(event, nodeData) {
  try {
    const webhookUrl = `${BACKEND_URL}${WEBHOOK_PATH}`;
    const url = new URL(webhookUrl);
    const protocol = url.protocol === 'https:' ? https : http;
    
    const payload = JSON.stringify({
      event: event,
      nodeId: nodeData.nodeId,
      nodeName: nodeData.hostname,
      hostname: nodeData.hostname,
      connected: nodeData.connected,
      timestamp: new Date().toISOString(),
      node: {
        platform: nodeData.platform,
        osdesc: nodeData.osdesc,
        netif: nodeData.netif || {},
        mac: nodeData.macAddresses && nodeData.macAddresses.length > 0 ? nodeData.macAddresses[0] : null
      }
    });
    
    const options = {
      hostname: url.hostname,
      port: url.port,
      path: url.pathname,
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Content-Length': Buffer.byteLength(payload),
        'X-MeshCentral-Secret': WEBHOOK_SECRET
      }
    };
    
    return new Promise((resolve, reject) => {
      const req = protocol.request(options, (res) => {
        let data = '';
        res.on('data', chunk => data += chunk);
        res.on('end', () => {
          if (res.statusCode >= 200 && res.statusCode < 300) {
            const responseData = JSON.parse(data || '{}');
            if (responseData.linkResult) {
              const result = responseData.linkResult;
              if (result.created) {
                console.log(`🆕 [WebhookMonitor] Created new agent ${result.agentId} for ${nodeData.hostname}`);
              } else if (result.alreadyLinked) {
                console.log(`✅ [WebhookMonitor] Device already linked to agent ${result.agentId}`);
              } else if (result.success) {
                console.log(`🔗 [WebhookMonitor] Linked agent ${result.agentId} via ${result.method}`);
              } else {
                console.log(`ℹ️  [WebhookMonitor] No action: ${result.reason}`);
              }
            } else {
              console.log(`📤 [WebhookMonitor] Webhook sent: ${event} for ${nodeData.hostname}`);
            }
            resolve(responseData);
          } else {
            console.error(`❌ [WebhookMonitor] Webhook failed: ${res.statusCode} ${data}`);
            reject(new Error(`HTTP ${res.statusCode}`));
          }
        });
      });
      
      req.on('error', error => {
        console.error('❌ [WebhookMonitor] Webhook error:', error.message);
        reject(error);
      });
      
      req.write(payload);
      req.end();
    });
    
  } catch (error) {
    console.error('❌ [WebhookMonitor] Error sending webhook:', error.message);
  }
}
 
/**
 * Check devices and detect state changes
 */
async function checkDevices() {
  try {
    const api = new MeshCentralAPI({
      url: MESHCENTRAL_URL,
      username: MESHCENTRAL_USER,
      password: MESHCENTRAL_PASS
    });
    
    await api.login();
    const nodes = await api.getNodes();
    
    // console.log(`🔍 [WebhookMonitor] Checking ${nodes.length} devices...`);
    
    for (const node of nodes) {
      const parsed = MeshCentralAPI.parseNodeData(node);
      const nodeId = parsed.nodeId;
      const wasConnected = deviceStates.get(nodeId);
      const isConnected = parsed.connected;
      
      // Store current state
      deviceStates.set(nodeId, isConnected);
      
      // Detect state change
      if (wasConnected === undefined) {
        // First time seeing this device
        if (isConnected) {
          console.log(`📱 [WebhookMonitor] New device detected: ${parsed.hostname} (connected)`);
          await sendWebhook('device.connect', parsed);
        }
      } else if (wasConnected !== isConnected) {
        // Connection state changed
        if (isConnected) {
          console.log(`✅ [WebhookMonitor] Device connected: ${parsed.hostname}`);
          await sendWebhook('device.connect', parsed);
        } else {
          console.log(`📴 [WebhookMonitor] Device disconnected: ${parsed.hostname}`);
          await sendWebhook('device.disconnect', parsed);
        }
      }
    }
    
  } catch (error) {
    console.error('❌ [WebhookMonitor] Error checking devices:', error.message);
  }
}
 
/**
 * Main monitoring loop
 */
async function startMonitoring() {
  console.log('\n🚀 MeshCentral Webhook Monitor Starting...');
  console.log(`   MeshCentral: ${MESHCENTRAL_URL}`);
  console.log(`   Backend: ${BACKEND_URL}`);
  console.log(`   Webhook: ${WEBHOOK_PATH}`);
  console.log(`   Secret: ${WEBHOOK_SECRET ? '✅ Configured' : '⚠️  Not configured'}`);
  console.log('');
  
  // Initial check
  await checkDevices();
  
  // Poll every 10 seconds
  setInterval(async () => {
    await checkDevices();
  }, 10000);
  
  console.log('✅ [WebhookMonitor] Monitoring started (checking every 10 seconds)');
}
 
// Handle graceful shutdown
process.on('SIGTERM', () => {
  console.log('\n👋 [WebhookMonitor] Shutting down...');
  process.exit(0);
});
 
process.on('SIGINT', () => {
  console.log('\n👋 [WebhookMonitor] Shutting down...');
  process.exit(0);
});
 
// Start monitoring
startMonitoring().catch(error => {
  console.error('❌ [WebhookMonitor] Fatal error:', error);
  process.exit(1);
});