rmm-webhook.js

Go to the documentation of this file.

/**
 * @description RMM-PSA Webhook Notifier Plugin for MeshCentral
 * @author Independent Business Group
 * @copyright 2026
 * @license Apache-2.0
 * @version 1.0.0
 * 
 * This plugin sends webhooks to the RMM-PSA backend for real-time device events:
 * - Device connect/disconnect
 * - Device information changes
 * - Node status updates
 * 
 * This provides instant updates (< 2s) vs 5-minute polling lag.
 */
 
'use strict';
 
module.exports['rmm-webhook'] = function(pluginHandler) {
  const obj = {};
  const parent = pluginHandler.parent;
  
  // Configuration from environment variables or config.json
  const webhookUrl = process.env.MESHCENTRAL_WEBHOOK_URL || 
                     parent.config.settings.rmmWebhookUrl || 
                     'https://rmm-psa-backend-t9f7k.ondigitalocean.app/api/webhooks/meshcentral';
  
  const webhookSecret = process.env.MESHCENTRAL_WEBHOOK_SECRET || 
                        parent.config.settings.rmmWebhookSecret || 
                        '';
  
  console.log('=================================================');
  console.log('📡 RMM-PSA Webhook Notifier Plugin Loaded');
  console.log(`   Webhook URL: ${webhookUrl}`);
  console.log(`   Secret configured: ${webhookSecret ? 'YES ✅' : 'NO ⚠️'}`);
  console.log('=================================================');
  
  /**
   * Send webhook to RMM-PSA backend
   */
  async function sendWebhook(event, node, meshId) {
    try {
      const https = require('https');
      const http = require('http');
      const url = require('url');
      
      const parsedUrl = url.parse(webhookUrl);
      const protocol = parsedUrl.protocol === 'https:' ? https : http;
      
      const payload = JSON.stringify({
        event: event,
        nodeId: node._id || node.nodeid,
        nodeName: node.name,
        hostname: node.host,
        meshId: meshId || node.meshid,
        connected: (node.conn & 1) === 1,
        timestamp: new Date().toISOString(),
        node: {
          platform: node.osdesc,
          ip: node.ip,
          mac: node.mac
        }
      });
      
      const options = {
        hostname: parsedUrl.hostname,
        port: parsedUrl.port || (parsedUrl.protocol === 'https:' ? 443 : 80),
        path: parsedUrl.path,
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Content-Length': payload.length,
          'X-MeshCentral-Secret': webhookSecret
        }
      };
      
      const req = protocol.request(options, (res) => {
        let responseData = '';
        res.on('data', (chunk) => { responseData += chunk; });
        res.on('end', () => {
          if (res.statusCode === 200) {
            console.log(`✅ [RMM-Webhook] ${event} for ${node.name} (${res.statusCode})`);
          } else {
            console.log(`⚠️  [RMM-Webhook] ${event} for ${node.name} (${res.statusCode}) - ${responseData}`);
          }
        });
      });
      
      req.on('error', (error) => {
        console.error(`❌ [RMM-Webhook] Error sending ${event}:`, error.message);
      });
      
      req.write(payload);
      req.end();
      
    } catch (error) {
      console.error('❌ [RMM-Webhook] Send error:', error.message);
    }
  }
  
  /**
   * Hook: Device connected
   * Called when a device connects to MeshCentral
   */
  obj.hook_onDeviceConnected = function(device, meshId) {
    console.log(`📱 [RMM-Webhook] Device connected: ${device.name}`);
    sendWebhook('device.connect', device, meshId);
  };
  
  /**
   * Hook: Device disconnected
   * Called when a device disconnects from MeshCentral
   */
  obj.hook_onDeviceDisconnected = function(device, meshId) {
    console.log(`📴 [RMM-Webhook] Device disconnected: ${device.name}`);
    sendWebhook('device.disconnect', device, meshId);
  };
  
  /**
   * Hook: Device changed
   * Called when device information is updated
   */
  obj.hook_onDeviceChanged = function(device, meshId) {
    console.log(`🔄 [RMM-Webhook] Device changed: ${device.name}`);
    sendWebhook('device.change', device, meshId);
  };
  
  /**
   * Hook: Node connect event
   * Alternative hook for node connections
   */
  obj.hook_onNodeConnect = function(device, meshId) {
    console.log(`📱 [RMM-Webhook] Node connected: ${device.name}`);
    sendWebhook('node.connect', device, meshId);
  };
  
  /**
   * Hook: Node disconnect event
   * Alternative hook for node disconnections
   */
  obj.hook_onNodeDisconnect = function(device, meshId) {
    console.log(`📴 [RMM-Webhook] Node disconnected: ${device.name}`);
    sendWebhook('node.disconnect', device, meshId);
  };
  
  // Export functions (required by plugin system)
  obj.exports = [];
  
  return obj;
};