debug.js

Go to the documentation of this file.

/**
 * @file debug.js
 * @module routes/debug
 * @description Debug endpoints for troubleshooting MeshCentral integration and tenant configuration.
 * Provides comprehensive diagnostic information about tenants, mesh groups, devices, and backend agents.
 * @requires express
 * @requires middleware/auth
 * @requires services/db
 * @requires services/meshcentral-db
 * @author RMM-PSA Development Team
 * @copyright 2026 RMM-PSA Platform
 * @license Proprietary
 */
 
/**
 * @apiDefine Debug Debugging
 * Diagnostic endpoints for troubleshooting integrations
 */
 
const express = require('express');
const router = express.Router();
const authenticateToken = require('../middleware/auth');
const { meshPool } = require('../services/meshcentral-db');
 
/**
 * @api {get} /api/debug/meshcentral MeshCentral configuration debug
 * @apiName GetMeshCentralDebug
 * @apiGroup Debug
 * @apiDescription Comprehensive diagnostic endpoint for troubleshooting MeshCentral integration.
 * Returns tenant-mesh group mappings, all mesh groups, all devices, backend agent mappings,
 * and connectivity status. Useful for debugging device sync issues and tenant isolation problems.
 * @apiSuccess {string} timestamp Request timestamp (ISO 8601)
 * @apiSuccess {object} user Request user context
 * @apiSuccess {number} user.id User ID
 * @apiSuccess {number} user.tenantId Tenant ID
 * @apiSuccess {object} currentTenant Current tenant details
 * @apiSuccess {number} currentTenant.tenant_id Tenant ID
 * @apiSuccess {string} currentTenant.name Tenant name
 * @apiSuccess {string} currentTenant.meshcentral_group_id Assigned mesh group ID
 * @apiSuccess {object[]} allTenants All tenants with mesh group assignments
 * @apiSuccess {number} allTenants.tenant_id Tenant ID
 * @apiSuccess {string} allTenants.name Tenant name
 * @apiSuccess {string} allTenants.meshcentral_group_id Mesh group ID (if assigned)
 * @apiSuccess {boolean} allTenants.hasMeshGroup Whether tenant has mesh group
 * @apiSuccess {Object[]} meshGroups All mesh groups from MeshCentral
 * @apiSuccess {string} meshGroups.mesh_id Mesh group ID from MeshCentral
 * @apiSuccess {string} meshGroups.mesh_name Mesh group name
 * @apiSuccess {string} meshGroups.description Mesh group description
 * @apiSuccess {Object[]} allDevices All devices from MeshCentral
 * @apiSuccess {string} allDevices.node_id MeshCentral node ID
 * @apiSuccess {string} allDevices.hostname Device hostname
 * @apiSuccess {string} allDevices.mesh_id Mesh group ID
 * @apiSuccess {String} allDevices.os Operating system description
 * @apiSuccess {Number} allDevices.conn_status Connection status bitmask
 * @apiSuccess {Boolean} allDevices.online Online status (derived from conn_status)
 * @apiSuccess {Object[]} currentTenantDevices Devices for current tenant's mesh group
 * @apiSuccess {Object[]} backendAgents Recent backend RMM agents (limit 20)
 * @apiSuccess {Number} backendAgents.agent_id Backend agent ID
 * @apiSuccess {String} backendAgents.agent_uuid Agent UUID
 * @apiSuccess {String} backendAgents.hostname Agent hostname
 * @apiSuccess {String} backendAgents.meshcentral_nodeid Linked MeshCentral node ID
 * @apiSuccess {Number} backendAgents.tenant_id Tenant ID
 * @apiSuccess {String} backendAgents.status Agent status
 * @apiSuccess {Object} summary Debug summary statistics
 * @apiSuccess {Number} summary.totalTenants Total tenant count
 * @apiSuccess {Number} summary.tenantsWithMeshGroup Tenants with mesh groups
 * @apiSuccess {Number} summary.totalMeshGroups Total mesh groups in MeshCentral
 * @apiSuccess {Number} summary.totalDevicesInMeshCentral Total devices in MeshCentral
 * @apiSuccess {Number} summary.devicesForCurrentTenant Devices for current tenant
 * @apiSuccess {Number} summary.totalBackendAgents Backend agents in database
 * 
 * @apiError {String} error Error message
 * @apiError {String} stack Error stack trace
 * 
 * @apiExample {curl} Example:
 *   curl -X GET http://localhost:3000/api/debug/meshcentral \\\
 *     -H "Authorization: Bearer YOUR_TOKEN"
 * 
 * @apiSuccessExample {json} Success-Response:
 *   HTTP/1.1 200 OK
 *   {
 *     "timestamp": "2026-03-12T10:45:00.000Z",
 *     "user": {
 *       "id": 5,
 *       "tenantId": 2
 *     },
 *     "currentTenant": {
 *       "tenant_id": 2,
 *       "name": "Acme Corp",
 *       "meshcentral_group_id": "mesh//abc123xyz"
 *     },
 *     "allTenants": [
 *       {
 *         "tenant_id": 1,
 *         "name": "MSP HQ",
 *         "meshcentral_group_id": "mesh//msp001",
 *         "hasMeshGroup": true
 *       }
 *     ],
 *     "meshGroups": [
 *       {
 *         "mesh_id": "mesh//abc123xyz",
 *         "mesh_name": "Acme Corp Devices",
 *         "description": "All devices for Acme"
 *       }
 *     ],
 *     "allDevices": [
 *       {
 *         "node_id": "node//server01",
 *         "hostname": "SERVER01",
 *         "mesh_id": "mesh//abc123xyz",
 *         "os": "Windows Server 2022",
 *         "conn_status": 1,
 *         "online": true
 *       }
 *     ],
 *     "summary": {
 *       "totalTenants": 15,
 *       "tenantsWithMeshGroup": 12,
 *       "totalMeshGroups": 12,
 *       "totalDevicesInMeshCentral": 145,
 *       "devicesForCurrentTenant": 22,
 *       "totalBackendAgents": 20
 *     }
 *   }
 */
router.get('/meshcentral', authenticateToken, async (req, res) => {
  const pool = require('../services/db');
  
  try {
    const debug = {
      timestamp: new Date().toISOString(),
      user: {
        id: req.user.userId,
        tenantId: req.user.tenantId
      }
    };
    
    // 1. Get current tenant info
    const currentTenant = await pool.query(
      'SELECT tenant_id, name, meshcentral_group_id FROM tenants WHERE tenant_id = $1',
      [req.user.tenantId]
    );
    
    debug.currentTenant = currentTenant.rows[0] || null;
    
    // 2. Get all tenants and their mesh groups
    const allTenants = await pool.query(
      'SELECT tenant_id, name, meshcentral_group_id FROM tenants ORDER BY name'
    );
    
    debug.allTenants = allTenants.rows.map(t => ({
      ...t,
      hasMeshGroup: !!t.meshcentral_group_id
    }));
    
    // 3. Get all mesh groups from MeshCentral
    try {
      const meshGroups = await meshPool.query(`
        SELECT 
          (doc->>'_id') as mesh_id,
          (doc->>'name') as mesh_name,
          (doc->>'desc') as description
        FROM main
        WHERE (doc->>'type') = 'mesh'
        ORDER BY (doc->>'name')
      `);
      
      debug.meshGroups = meshGroups.rows;
    } catch (err) {
      debug.meshGroups = { error: err.message };
    }
    
    // 4. Get all devices from MeshCentral
    try {
      const allDevices = await meshPool.query(`
        SELECT 
          (doc->>'_id') as node_id,
          (doc->>'name') as hostname,
          (doc->>'meshid') as mesh_id,
          (doc->'agent'->>'osdesc') as os,
          (doc->>'conn')::int as conn_status
        FROM main
        WHERE (doc->>'type') = 'node'
        ORDER BY (doc->>'name')
      `);
      
      debug.allDevices = allDevices.rows.map(d => ({
        ...d,
        online: (d.conn_status & 1) > 0 || (d.conn_status & 16) > 0
      }));
    } catch (err) {
      debug.allDevices = { error: err.message };
    }
    
    // 5. Get devices for current tenant's mesh group
    if (debug.currentTenant?.meshcentral_group_id) {
      try {
        const tenantDevices = await meshPool.query(`
          SELECT 
            (doc->>'_id') as node_id,
            (doc->>'name') as hostname,
            (doc->>'meshid') as mesh_id,
            (doc->>'conn')::int as conn_status
          FROM main
          WHERE (doc->>'type') = 'node'
          AND (doc->>'meshid') = $1
          ORDER BY (doc->>'name')
        `, [debug.currentTenant.meshcentral_group_id]);
        
        debug.currentTenantDevices = tenantDevices.rows.map(d => ({
          ...d,
          online: (d.conn_status & 1) > 0 || (d.conn_status & 16) > 0
        }));
      } catch (err) {
        debug.currentTenantDevices = { error: err.message };
      }
    } else {
      debug.currentTenantDevices = { error: 'No mesh group assigned to tenant' };
    }
    
    // 6. Get backend agents
    const backendAgents = await pool.query(
      'SELECT agent_id, agent_uuid, hostname, meshcentral_nodeid, tenant_id, status FROM agents ORDER BY agent_id DESC LIMIT 20'
    );
    
    debug.backendAgents = backendAgents.rows;
    
    // 7. Summary
    debug.summary = {
      totalTenants: debug.allTenants.length,
      tenantsWithMeshGroup: debug.allTenants.filter(t => t.hasMeshGroup).length,
      totalMeshGroups: Array.isArray(debug.meshGroups) ? debug.meshGroups.length : 0,
      totalDevicesInMeshCentral: Array.isArray(debug.allDevices) ? debug.allDevices.length : 0,
      devicesForCurrentTenant: Array.isArray(debug.currentTenantDevices) ? debug.currentTenantDevices.length : 0,
      totalBackendAgents: debug.backendAgents.length
    };
    
    res.json(debug);
  } catch (err) {
    console.error('Debug endpoint error:', err);
    res.status(500).json({ error: err.message, stack: err.stack });
  }
});
 
module.exports = router;