monitoring.js

Go to the documentation of this file.

/**
 * @file monitoring.js
 * @module MonitoringRoutes
 * @description Agent monitoring and device assignment routes. Retrieves paginated lists of agents with connection status, search, and tenant filtering. Supports device assignment to tenants and customers, with optional MeshCentral mesh group relocation. Database is the source of truth, kept in sync by auto-sync worker.
 * @see {@link ../lib/meshcentral-api} for MeshCentral API integration
 * @see {@link ../services/db} for database connection
 * @see {@link ../middleware/auth} for authentication middleware
 * @see {@link ../middleware/tenant} for tenant context utilities
 * @apiDefine MonitoringGroup Monitoring
 * @apiGroup Monitoring
 * @apiHeader {string} Authorization Bearer token required.
 * @apiHeader {string} [X-Tenant-ID] Tenant context header (optional for root/MSP users).
 * @apiError (Error 401) Unauthorized Missing or invalid token.
 * @apiError (Error 403) Forbidden Only administrators can assign devices.
 * @apiError (Error 404) NotFound Device or tenant not found.
 * @apiError (Error 500) ServerError Internal server error.
 */
 
const express = require('express');
const router = express.Router();
const authenticateToken = require('../middleware/auth');
 
const { getTenantFilter, setTenantContext } = require('../middleware/tenant');
const MeshCentralAPI = require('../lib/meshcentral-api');
 
/**
 * @api {get} /monitoring Get monitoring data (agent list with stats)
 * @apiName GetMonitoring
 * @apiGroup Monitoring
 * @apiDescription Retrieve paginated list of agents with connection status, tenant/customer info, and global stats (total, online, offline). Database is the source of truth (kept in sync by auto-sync worker). Supports search filtering and MSP tenant impersonation.
 * @apiParam {number} [page=1] Page number for pagination.
 * @apiParam {number} [limit=20] Number of agents per page.
 * @apiParam {string} [search] Search term for hostname, name, or MeshCentral node ID.
 * @apiParam {string} [tenantId] Tenant ID for MSP impersonation (root/MSP users only).
 * @apiSuccess {object[]} agents List of agents.
 * @apiSuccess {string} agents.agent_id Agent ID.
 * @apiSuccess {string} agents.agent_uuid Agent UUID.
 * @apiSuccess {string} agents.hostname Agent hostname.
 * @apiSuccess {string} agents.platform Platform (windows, linux, darwin).
 * @apiSuccess {string} agents.os Operating system.
 * @apiSuccess {string} agents.os_version OS version.
 * @apiSuccess {string} agents.tenant_id Tenant ID.
 * @apiSuccess {string} agents.tenant_name Tenant name.
 * @apiSuccess {string} agents.customer_id Customer ID.
 * @apiSuccess {string} agents.customer_name Customer name.
 * @apiSuccess {boolean} agents.meshcentral_connected MeshCentral connection status.
 * @apiSuccess {string} agents.status Status (online/offline).
 * @apiSuccess {Date} agents.last_seen Last seen timestamp.
 * @apiSuccess {boolean} agents.is_untagged Whether agent is untagged.
 * @apiSuccess {Number} total Total agent count.
 * @apiSuccess {Object} overview Global stats.
 * @apiSuccess {Number} overview.totalAgents Total agents.
 * @apiSuccess {Number} overview.agentsOnline Online agents.
 * @apiSuccess {Number} overview.agentsOffline Offline agents.
 * @apiSuccess {Number} page Current page.
 * @apiSuccess {Number} perPage Agents per page.
 *
 * @apiExample {curl} Example usage:
 *     curl -H "Authorization: Bearer <token>" -H "X-Tenant-ID: <id>" https://api.example.com/monitoring?page=1&limit=20&search=server
 */
router.get('/', authenticateToken, setTenantContext, async (req, res) => {
  const pool = require('../services/db');
  try {
    const page = parseInt(req.query.page, 10) || 1;
    const limit = parseInt(req.query.limit, 10) || 20;
    const offset = (page - 1) * limit;
    const search = req.query.search || '';
    
    console.log('[Monitoring] Request received:', {
      user: req.user,
      tenant: req.tenant,
      query: req.query
    });
    
    // For root/MSP users, allow filtering by selected tenant (impersonation)
    let effectiveTenant = req.tenant;
    if (req.tenant && req.tenant.isMsp) {
      const selectedTenantId = req.query.tenantId || req.query.tenant_id;
      if (selectedTenantId) {
        effectiveTenant = { ...req.tenant, id: selectedTenantId, isMsp: false };
      }
    }
 
    const isRootOrMsp = req.tenant.isMsp || effectiveTenant.id === '00000000-0000-0000-0000-000000000001';
    
    console.log('[Monitoring] Query context:', {
      tenantId: effectiveTenant.id,
      isRootOrMsp,
      search
    });
 
    // Build tenant filter for query
    let whereClause = '';
    let params = [];
    let paramIndex = 1;
 
    if (!isRootOrMsp) {
      whereClause = `WHERE a.tenant_id = $${paramIndex}`;
      params.push(effectiveTenant.id);
      paramIndex++;
    } else {
      // Root/MSP users see all agents
      whereClause = 'WHERE 1=1';
    }
 
    // Add search filter
    if (search) {
      whereClause += ` AND (
        LOWER(a.hostname) LIKE LOWER($${paramIndex}) OR
        LOWER(a.name) LIKE LOWER($${paramIndex}) OR
        LOWER(a.meshcentral_nodeid) LIKE LOWER($${paramIndex})
      )`;
      params.push(`%${search}%`);
      paramIndex++;
    }
 
    // Get total count
    const countResult = await pool.query(
      `SELECT COUNT(*) as total FROM agents a ${whereClause}`,
      params
    );
    const total = parseInt(countResult.rows[0].total, 10);
 
    // Get paginated agents from our database
    const agentsResult = await pool.query(
      `SELECT 
        a.agent_id,
        a.agent_uuid,
        a.tenant_id,
        a.customer_id,
        a.hostname,
        a.name,
        a.platform,
        a.os,
        a.os_version,
        a.meshcentral_nodeid,
        a.meshcentral_connected,
        a.meshcentral_last_seen,
        a.status,
        a.last_seen,
        a.created_at,
        t.name as tenant_name,
        t.meshcentral_group_id,
        c.name as customer_name
      FROM agents a
      LEFT JOIN tenants t ON a.tenant_id = t.tenant_id
      LEFT JOIN customers c ON a.customer_id = c.customer_id
      ${whereClause}
      ORDER BY a.meshcentral_connected DESC, a.last_seen DESC NULLS LAST
      LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`,
      [...params, limit, offset]
    );
 
    const agents = agentsResult.rows;
 
    // Calculate stats (from ALL agents, not just paginated)
    const statsResult = await pool.query(
      `SELECT 
        COUNT(*) as total,
        SUM(CASE WHEN meshcentral_connected = true THEN 1 ELSE 0 END) as online,
        SUM(CASE WHEN meshcentral_connected = false OR meshcentral_connected IS NULL THEN 1 ELSE 0 END) as offline
      FROM agents a
      ${whereClause}`,
      params
    );
 
    const stats = statsResult.rows[0];
    const agentsOnline = parseInt(stats.online, 10) || 0;
    const agentsOffline = parseInt(stats.offline, 10) || 0;
    const totalAgents = parseInt(stats.total, 10) || 0;
 
    console.log('[Monitoring] Stats:', {
      total: totalAgents,
      online: agentsOnline,
      offline: agentsOffline,
      pageSize: agents.length
    });
 
    // Map agents to frontend format
    const mappedAgents = agents.map(a => ({
      agent_id: a.agent_id,
      agent_uuid: a.agent_uuid,
      hostname: a.hostname || a.name || 'Unknown',
      name: a.name || a.hostname,
      platform: a.platform,
      os: a.os,
      os_version: a.os_version,
      tenant_id: a.tenant_id,
      tenant_name: a.tenant_name,
      customer_id: a.customer_id,
      customer_name: a.customer_name,
      meshcentral_nodeid: a.meshcentral_nodeid,
      meshcentral_connected: a.meshcentral_connected || false,
      mesh_id: a.meshcentral_group_id,
      status: a.meshcentral_connected ? 'online' : 'offline',
      last_seen: a.meshcentral_last_seen || a.last_seen,
      created_at: a.created_at,
      is_untagged: !a.tenant_id || !a.meshcentral_nodeid
    }));
 
    res.json({
      agents: mappedAgents,
      total: totalAgents,
      overview: {
        totalAgents: totalAgents,
        agentsOnline: agentsOnline,
        agentsOffline: agentsOffline
      },
      page,
      perPage: limit
    });
  } catch (err) {
    console.error('[Monitoring] Error fetching monitoring data:', err);
    res.status(500).json({ error: 'Server error', message: err.message });
  }
});
 
/**
 * @api {post} /monitoring/assign-device Assign untagged device to tenant
 * @apiName AssignDevice
 * @apiGroup Monitoring
 * @apiDescription Assign an untagged MeshCentral device to a tenant and optionally to a customer. Updates device tags in MeshCentral and creates/updates agent in the database. Optionally moves device to tenant's MeshCentral mesh group. Only root/MSP users can assign devices.
 * @apiParam {string} nodeId MeshCentral node ID.
 * @apiParam {string} tenantId Tenant ID to assign to.
 * @apiParam {string} [customerId] Customer ID to assign to (optional).
 * @apiParam {boolean} [moveMesh=false] Whether to move device to tenant's mesh group.
 * @apiSuccess {boolean} success Operation success status.
 * @apiSuccess {object} device Assigned device details.
 * @apiSuccess {string} device.nodeId MeshCentral node ID.
 * @apiSuccess {string} device.hostname Device hostname.
 * @apiSuccess {string} device.tenantId Assigned tenant ID.
 * @apiSuccess {string} device.tenantName Assigned tenant name.
 * @apiSuccess {string} device.customerId Assigned customer ID.
 * @apiSuccess {boolean} device.moved Whether device was moved to tenant's mesh group.
 * @apiError (Error 400) BadRequest nodeId and tenantId are required.
 * @apiError (Error 403) Forbidden Only administrators can assign devices.
 * @apiError (Error 404) NotFound Device or tenant not found.
 * @apiExample {curl} Example usage:
 *     curl -X POST -H "Authorization: Bearer <token>" -d '{"nodeId":"node//abc123","tenantId":"tenant-id","customerId":"customer-id","moveMesh":true}' https://api.example.com/monitoring/assign-device
 */
router.post('/assign-device', authenticateToken, setTenantContext, async (req, res) => {
  const pool = require('../services/db');
  try {
    const { nodeId, tenantId, customerId, moveMesh = false } = req.body;
    
    // Only root/MSP users can assign devices
    if (!req.tenant.isMsp) {
      return res.status(403).json({ error: 'Only administrators can assign devices' });
    }
    
    if (!nodeId || !tenantId) {
      return res.status(400).json({ error: 'nodeId and tenantId are required' });
    }
    
    // Get tenant info
    const tenantResult = await pool.query(
      'SELECT tenant_id, name, meshcentral_group_id FROM tenants WHERE tenant_id = $1',
      [tenantId]
    );
    
    if (tenantResult.rows.length === 0) {
      return res.status(404).json({ error: 'Tenant not found' });
    }
    
    const tenant = tenantResult.rows[0];
    
    // Connect to MeshCentral
    const meshcentral = new MeshCentralAPI({
      url: process.env.MESHCENTRAL_URL,
      username: process.env.MESHCENTRAL_ADMIN_USER || process.env.MESHCENTRAL_USERNAME,
      password: process.env.MESHCENTRAL_ADMIN_PASS || process.env.MESHCENTRAL_PASSWORD
    });
    
    await meshcentral.login();
    const node = await meshcentral.getNode(nodeId);
    
    if (!node) {
      return res.status(404).json({ error: 'Device not found in MeshCentral' });
    }
    
    const parsed = MeshCentralAPI.parseNodeData(node);
    const tagData = MeshCentralAPI.parseDeviceTags(node.tags);
    
    // Update device tags in MeshCentral
    await meshcentral.updateDeviceMetadata(nodeId, {
      tenantId: tenantId,
      customerId: customerId,
      tags: tagData.customTags
    });
    
    console.log(`✅ Tagged device ${parsed.hostname} with tenant ${tenantId}`);
    
    // Create or update agent in database
    const agentCheck = await pool.query(
      'SELECT agent_id FROM agents WHERE meshcentral_nodeid = $1',
      [nodeId]
    );
    
    if (agentCheck.rows.length > 0) {
      // Update existing agent
      await pool.query(
        `UPDATE agents 
         SET tenant_id = $1, customer_id = $2, meshcentral_connected = $3, last_seen = $4
         WHERE meshcentral_nodeid = $5`,
        [tenantId, customerId, parsed.connected, parsed.lastSeen, nodeId]
      );
      console.log(`✅ Updated agent ${agentCheck.rows[0].agent_id} in database`);
    } else {
      // Create new agent
      const { v4: uuidv4 } = require('uuid');
      await pool.query(
        `INSERT INTO agents (
          tenant_id, customer_id, hostname, platform, os, os_version, 
          agent_uuid, meshcentral_nodeid, meshcentral_connected, 
          last_seen, status, created_at
        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, NOW())`,
        [
          tenantId,
          customerId,
          parsed.hostname,
          parsed.platform,
          parsed.os,
          parsed.osVersion,
          uuidv4(),
          nodeId,
          parsed.connected,
          parsed.lastSeen,
          parsed.connected ? 'online' : 'offline'
        ]
      );
      console.log(`✅ Created new agent for ${parsed.hostname} in database`);
    }
    
    // Optionally move device to tenant's mesh group
    let moved = false;
    if (moveMesh && tenant.meshcentral_group_id && node.meshid !== tenant.meshcentral_group_id) {
      try {
        await meshcentral._sendWebSocketMessage({
          action: 'changeDeviceMesh',
          nodeids: [nodeId],
          meshid: tenant.meshcentral_group_id
        });
        moved = true;
        console.log(`✅ Moved device to ${tenant.name} mesh group`);
      } catch (moveErr) {
        console.error('Failed to move device to tenant mesh:', moveErr);
      }
    }
    
    res.json({
      success: true,
      device: {
        nodeId: nodeId,
        hostname: parsed.hostname,
        tenantId: tenantId,
        tenantName: tenant.name,
        customerId: customerId,
        moved: moved
      }
    });
  } catch (err) {
    console.error('Error assigning device:', err);
    res.status(500).json({ error: 'Failed to assign device', message: err.message });
  }
});
 
module.exports = router;