meshcentral-device-sync.js

Go to the documentation of this file.

/**
 * MeshCentral Device and Group Auto-Sync Worker
 * 
 * Polls MeshCentral and our database to ensure synchronization:
 * - Syncs mesh groups from our DB tenants to MeshCentral
 * - Creates new agents in our database for untracked devices
 * - Updates connection status for existing agents
 * - Links MeshCentral node IDs to agents
 * 
 * This makes our PostgreSQL database the source of truth for both
 * agents and mesh groups, preventing duplicates and ensuring persistence.
 * 
 * NOTE: Polling is used as a fallback. Once MeshCentral webhooks are configured
 * (see /api/webhooks/meshcentral and MESHCENTRAL_WEBHOOK_SETUP.md), webhooks 
 * will provide real-time updates (~2s) and this polling can be reduced to a
 * 10-minute fallback interval for missed events.
 */
 
const MeshCentralAPI = require('../lib/meshcentral-api');
const { getDevices } = require('../services/meshcentral-db');
const db = require('../db');
const crypto = require('crypto');
 
const SYNC_INTERVAL = 300000; // 5 minutes (will reduce to 10min once webhooks are active)
const GROUP_SYNC_INTERVAL = 300000; // 5 minutes for mesh groups
const LOG_PREFIX = '[MeshSync]';
 
/**
 * MeshCentral device synchronization worker.
 * Syncs devices from MeshCentral to local agents database.
 */
class MeshCentralDeviceSync {
  /**
   * Initialize MeshCentralDeviceSync worker.
   * Sets up sync intervals, API instance, and statistics tracking.
   */
  constructor() {
    this.running = false;
    this.intervalId = null;
    this.groupIntervalId = null;
    this.lastSyncTime = null;
    this.lastGroupSyncTime = null;
    this.meshApi = null;
    this.stats = {
      totalSyncs: 0,
      devicesFound: 0,
      agentsCreated: 0,
      agentsLinked: 0,
      agentsUpdated: 0,
      groupsCreated: 0,
      groupsSynced: 0,
      errors: 0
    };
  }
 
  /**
   * Get or create MeshCentral API instance.
   * @returns {Promise<MeshCentralAPI>} Authenticated API client
   */
  async getMeshAPI() {
    if (!this.meshApi) {
      this.meshApi = new MeshCentralAPI({
        url: process.env.MESHCENTRAL_URL || 'https://rmm-psa-meshcentral-aq48h.ondigitalocean.app',
        username: process.env.MESHCENTRAL_ADMIN_USER || process.env.MESHCENTRAL_USERNAME,
        password: process.env.MESHCENTRAL_ADMIN_PASS || process.env.MESHCENTRAL_PASSWORD
      });
      await this.meshApi.login();
    }
    return this.meshApi;
  }
 
  /**
   * Start the sync worker
   */
  start() {
    if (this.running) {
      console.log(`${LOG_PREFIX} Already running`);
      return;
    }
 
    console.log(`${LOG_PREFIX} Starting device & group sync worker`);
    console.log(`${LOG_PREFIX} Device sync interval: ${SYNC_INTERVAL}ms`);
    console.log(`${LOG_PREFIX} Group sync interval: ${GROUP_SYNC_INTERVAL}ms`);
    this.running = true;
 
    // Run device sync immediately
    this.sync().catch(err => {
      console.error(`${LOG_PREFIX} Initial device sync failed:`, err.message);
    });
 
    // Run group sync after 2 seconds
    setTimeout(() => {
      this.syncMeshGroups().catch(err => {
        console.error(`${LOG_PREFIX} Initial group sync failed:`, err.message);
      });
    }, 2000);
 
    // Then run periodically
    this.intervalId = setInterval(() => {
      this.sync().catch(err => {
        console.error(`${LOG_PREFIX} Device sync failed:`, err.message);
        this.stats.errors++;
      });
    }, SYNC_INTERVAL);
 
    this.groupIntervalId = setInterval(() => {
      this.syncMeshGroups().catch(err => {
        console.error(`${LOG_PREFIX} Group sync failed:`, err.message);
        this.stats.errors++;
      });
    }, GROUP_SYNC_INTERVAL);
  }
 
  /**
   * Stop the sync worker
   */
  stop() {
    if (!this.running) return;
 
    console.log(`${LOG_PREFIX} Stopping device & group sync worker`);
    this.running = false;
 
    if (this.intervalId) {
      clearInterval(this.intervalId);
      this.intervalId = null;
    }
 
    if (this.groupIntervalId) {
      clearInterval(this.groupIntervalId);
      this.groupIntervalId = null;
    }
  }
 
  /**
   * Sync mesh groups from our database to MeshCentral
   * Our database is the source of truth for tenants and mesh groups
   */
  async syncMeshGroups() {
    try {
      console.log(`\n${LOG_PREFIX} 🔄 Starting mesh group sync...`);
      
      const api = await this.getMeshAPI();
 
      // Get all tenants from our database
      const tenantsResult = await db.query(`
        SELECT tenant_id, name, meshcentral_group_id 
        FROM tenants 
        WHERE tenant_id != '00000000-0000-0000-0000-000000000001'
        ORDER BY name
      `);
 
      const tenants = tenantsResult.rows;
      console.log(`${LOG_PREFIX} Found ${tenants.length} tenants to sync`);
 
      // Get all existing mesh groups from MeshCentral
      const existingMeshes = await api.getMeshes();
      const existingMeshMap = new Map();
      for (const mesh of existingMeshes) {
        existingMeshMap.set(mesh.meshid, mesh);
      }
 
      console.log(`${LOG_PREFIX} Found ${existingMeshes.length} existing mesh groups in MeshCentral`);
 
      // Track which meshes we want to keep
      const desiredMeshIds = new Set();
 
      // Process each tenant
      for (const tenant of tenants) {
        try {
          const desiredMeshName = `${tenant.name} Devices`;
          let meshId = tenant.meshcentral_group_id;
 
          // Check if tenant's mesh group exists in MeshCentral
          if (meshId && existingMeshMap.has(meshId)) {
            // Mesh exists - verify name matches
            const existingMesh = existingMeshMap.get(meshId);
            if (existingMesh.name !== desiredMeshName) {
              console.log(`${LOG_PREFIX} Mesh name mismatch for ${tenant.name}: "${existingMesh.name}" -> "${desiredMeshName}"`);
              // Update mesh name (MeshCentral API might not support this, so we'll skip for now)
            }
            desiredMeshIds.add(meshId);
            this.stats.groupsSynced++;
          } else {
            // Mesh doesn't exist or tenant not linked - create it
            console.log(`${LOG_PREFIX} 🆕 Creating mesh group for tenant: ${tenant.name}`);
            
            try {
              const newMesh = await api.createMesh(desiredMeshName);
              meshId = newMesh.meshid;
 
              // Update tenant with new mesh ID
              await db.query(
                'UPDATE tenants SET meshcentral_group_id = $1 WHERE tenant_id = $2',
                [meshId, tenant.tenant_id]
              );
 
              console.log(`${LOG_PREFIX} ✅ Created mesh group "${desiredMeshName}" (${meshId}) for tenant ${tenant.name}`);
              desiredMeshIds.add(meshId);
              this.stats.groupsCreated++;
            } catch (createErr) {
              // Mesh might already exist with this name - try to find it
              const matchingMesh = existingMeshes.find(m => m.name === desiredMeshName);
              if (matchingMesh) {
                console.log(`${LOG_PREFIX} Found existing mesh "${desiredMeshName}", linking to tenant ${tenant.name}`);
                await db.query(
                  'UPDATE tenants SET meshcentral_group_id = $1 WHERE tenant_id = $2',
                  [matchingMesh.meshid, tenant.tenant_id]
                );
                desiredMeshIds.add(matchingMesh.meshid);
                this.stats.groupsSynced++;
              } else {
                throw createErr;
              }
            }
          }
        } catch (err) {
          console.error(`${LOG_PREFIX} Error syncing mesh group for tenant ${tenant.name}:`, err.message);
          this.stats.errors++;
        }
      }
 
      // Clean up orphaned mesh groups (ones not in our DB)
      const orphanedMeshes = existingMeshes.filter(mesh => !desiredMeshIds.has(mesh.meshid));
      if (orphanedMeshes.length > 0) {
        console.log(`${LOG_PREFIX} Found ${orphanedMeshes.length} orphaned mesh groups:`);
        for (const mesh of orphanedMeshes) {
          console.log(`${LOG_PREFIX}   - ${mesh.name} (${mesh.meshid})`);
          // Optionally delete orphaned meshes (commented out for safety)
          // await api.deleteMesh(mesh.meshid);
          // console.log(`${LOG_PREFIX}   ✅ Deleted orphaned mesh group "${mesh.name}"`);
        }
      }
 
      this.lastGroupSyncTime = new Date();
      console.log(`${LOG_PREFIX} ✅ Mesh group sync complete`);
 
    } catch (error) {
      console.error(`${LOG_PREFIX} Mesh group sync error:`, error);
      this.stats.errors++;
      throw error;
    }
  }
 
  /**
   * Main sync function
   */
  async sync() {
    try {
      const startTime = Date.now();
      console.log(`\n${LOG_PREFIX} Starting sync...`);
 
      // Get all devices from MeshCentral
      const devices = await getDevices(null); // null = get ALL devices
      this.stats.devicesFound = devices.length;
      this.stats.totalSyncs++;
 
      if (devices.length === 0) {
        console.log(`${LOG_PREFIX} No devices found in MeshCentral`);
        this.lastSyncTime = new Date();
        return;
      }
 
      console.log(`${LOG_PREFIX} Found ${devices.length} devices in MeshCentral`);
 
      // Process each device
      for (const device of devices) {
        try {
          await this.processDevice(device);
        } catch (err) {
          console.error(`${LOG_PREFIX} Error processing device ${device.nodeId}:`, err.message);
          this.stats.errors++;
        }
      }
 
      // Update disconnected devices
      await this.updateDisconnectedDevices(devices);
 
      const elapsed = Date.now() - startTime;
      console.log(`${LOG_PREFIX} Sync complete in ${elapsed}ms`);
      console.log(`${LOG_PREFIX} Stats:`, {
        created: this.stats.agentsCreated,
        linked: this.stats.agentsLinked,
        updated: this.stats.agentsUpdated
      });
 
      this.lastSyncTime = new Date();
 
    } catch (error) {
      console.error(`${LOG_PREFIX} Sync error:`, error);
      this.stats.errors++;
      throw error;
    }
  }
 
  /**
   * Process a single device from MeshCentral.
   * Creates or updates agent record in database.
   * @param {object} device - MeshCentral device object with nodeId, hostname, connected
   * @returns {Promise<void>}
   */
  async processDevice(device) {
    const nodeId = device.nodeId;
    const hostname = device.hostname || 'Unknown';
    const isConnected = device.connected || false;
 
    // Check if device is already linked to an agent
    const existingAgent = await db.query(
      'SELECT agent_id, hostname, meshcentral_connected FROM agents WHERE meshcentral_nodeid = $1',
      [nodeId]
    );
 
    if (existingAgent.rows.length > 0) {
      // Agent exists - update connection status
      const agent = existingAgent.rows[0];
      
      if (agent.meshcentral_connected !== isConnected) {
        await db.query(
          `UPDATE agents 
           SET meshcentral_connected = $1, 
               meshcentral_last_seen = NOW(),
               status = $2,
               last_seen = NOW()
           WHERE agent_id = $3`,
          [isConnected, isConnected ? 'online' : 'offline', agent.agent_id]
        );
        
        console.log(`${LOG_PREFIX} Updated agent ${agent.agent_id} (${agent.hostname}) - ${isConnected ? 'online' : 'offline'}`);
        this.stats.agentsUpdated++;
      }
      
      return;
    }
 
    // Device not linked - try to find matching agent by hostname
    const hostnameMatch = await db.query(
      'SELECT agent_id, agent_uuid, hostname, tenant_id FROM agents WHERE LOWER(hostname) = LOWER($1) AND meshcentral_nodeid IS NULL LIMIT 1',
      [hostname]
    );
 
    if (hostnameMatch.rows.length > 0) {
      // Found matching agent - link it
      const agent = hostnameMatch.rows[0];
      
      await db.query(
        `UPDATE agents 
         SET meshcentral_nodeid = $1, 
             meshcentral_connected = $2, 
             meshcentral_last_seen = NOW(),
             status = $3,
             last_seen = NOW()
         WHERE agent_id = $4`,
        [nodeId, isConnected, isConnected ? 'online' : 'offline', agent.agent_id]
      );
      
      console.log(`${LOG_PREFIX} ✅ Linked existing agent ${agent.agent_id} (${agent.hostname}) to device ${nodeId}`);
      this.stats.agentsLinked++;
      return;
    }
 
    // No matching agent found - create a new one
    console.log(`${LOG_PREFIX} 🆕 Creating new agent for device: ${hostname} (${nodeId})`);
    
    const newAgentUuid = crypto.randomUUID();
    
    // Determine platform
    let platform = 'unknown';
    if (device.platform) {
      const p = device.platform.toLowerCase();
      if (p.includes('windows')) platform = 'windows';
      else if (p.includes('linux')) platform = 'linux';
      else if (p.includes('darwin') || p.includes('mac')) platform = 'darwin';
    }
 
    // Get mesh group ID to determine tenant
    let tenantId = null;
    if (device.meshId) {
      const tenantMatch = await db.query(
        'SELECT tenant_id FROM tenants WHERE meshcentral_group_id = $1',
        [device.meshId]
      );
      if (tenantMatch.rows.length > 0) {
        tenantId = tenantMatch.rows[0].tenant_id;
      }
    }
 
    // If no tenant found, use default tenant (root)
    if (!tenantId) {
      const defaultTenant = await db.query(
        "SELECT tenant_id FROM tenants WHERE tenant_id = '00000000-0000-0000-0000-000000000001' LIMIT 1"
      );
      if (defaultTenant.rows.length > 0) {
        tenantId = defaultTenant.rows[0].tenant_id;
      }
    }
 
    // Create new agent
    const insertResult = await db.query(
      `INSERT INTO agents (
        agent_uuid, tenant_id, hostname, platform, 
        meshcentral_nodeid, meshcentral_connected, meshcentral_last_seen,
        status, last_seen, created_at
      ) VALUES ($1, $2, $3, $4, $5, $6, NOW(), $7, NOW(), NOW())
      RETURNING agent_id, agent_uuid, hostname`,
      [
        newAgentUuid, 
        tenantId, 
        hostname, 
        platform, 
        nodeId, 
        isConnected,
        isConnected ? 'online' : 'offline'
      ]
    );
 
    const newAgent = insertResult.rows[0];
    console.log(`${LOG_PREFIX} ✅ Created agent ${newAgent.agent_id} (${newAgent.hostname}) for device ${nodeId}`);
    this.stats.agentsCreated++;
  }
 
  /**
   * Mark agents as disconnected if they're not in the current device list.
   * @param {Array<object>} currentDevices - Array of current MeshCentral device objects
   * @returns {Promise<void>}
   */
  async updateDisconnectedDevices(currentDevices) {
    const connectedNodeIds = currentDevices.map(d => d.nodeId);
    
    if (connectedNodeIds.length === 0) {
      // If no devices, mark all as disconnected
      await db.query(
        `UPDATE agents 
         SET meshcentral_connected = false,
             status = 'offline'
         WHERE meshcentral_connected = true`
      );
      return;
    }
 
    // Mark agents as disconnected if their node ID is not in the current list
    const result = await db.query(
      `UPDATE agents 
       SET meshcentral_connected = false,
           status = 'offline'
       WHERE meshcentral_connected = true 
       AND meshcentral_nodeid IS NOT NULL
       AND NOT (meshcentral_nodeid = ANY($1))
       RETURNING agent_id, hostname`,
      [connectedNodeIds]
    );
 
    if (result.rowCount > 0) {
      console.log(`${LOG_PREFIX} Marked ${result.rowCount} agents as disconnected`);
      for (const agent of result.rows) {
        console.log(`${LOG_PREFIX}   - Agent ${agent.agent_id} (${agent.hostname}) went offline`);
      }
    }
  }
 
  /**
   * Get worker status and statistics.
   * @returns {object} Status object with running state, intervals, sync times, and stats
   */
  getStatus() {
    return {
      running: this.running,
      deviceSyncInterval: SYNC_INTERVAL,
      groupSyncInterval: GROUP_SYNC_INTERVAL,
      lastDeviceSync: this.lastSyncTime,
      lastGroupSync: this.lastGroupSyncTime,
      stats: this.stats
    };
  }
}
 
// Create singleton instance
const worker = new MeshCentralDeviceSync();
 
// Auto-start if enabled
if (process.env.MESHCENTRAL_AUTO_SYNC !== 'false') {
  console.log(`${LOG_PREFIX} Auto-sync enabled`);
  // Start after 5 seconds to allow server to fully initialize
  setTimeout(() => {
    worker.start();
  }, 5000);
} else {
  console.log(`${LOG_PREFIX} Auto-sync disabled (set MESHCENTRAL_AUTO_SYNC=true to enable)`);
}
 
// Export worker instance
module.exports = worker;