plugins.js

Go to the documentation of this file.

/**
 * @file plugins.js
 * @module PluginsRoutes
 * @description Plugin management API routes for RMM agent extensibility. Manages plugin catalog, file downloads, agent plugin initialization, and status tracking. Supports auto-sync from plugin directories and WebSocket-based plugin deployment to connected agents.
 * @see {@link ../services/db} for database connection
 * @see {@link ../services/websocketManager} for agent WebSocket connections
 * @see {@link ../middleware/auth} for authentication middleware
 * @see {@link ../middleware/tenant} for tenant context utilities
 * @apiDefine PluginsGroup Plugins
 * @apiGroup Plugins
 * @apiHeader {string} Authorization Bearer token required.
 * @apiError (Error 401) Unauthorized Missing or invalid token.
 * @apiError (Error 404) NotFound Plugin or agent not found.
 * @apiError (Error 500) ServerError Internal server error.
 */
 
const express = require('express');
const router = express.Router();
const pool = require('../services/db');
const authenticateToken = require('../middleware/auth');
const { getTenantFilter, setTenantContext } = require('../middleware/tenant');
const wsManager = require('../services/websocketManager');
 
 
// Utility: scan plugin directory and sync with DB
/**
 *
 */
async function syncPluginsWithDb() {
  const fs = require('fs');
  const path = require('path');
  const pluginDirs = [
    path.resolve(__dirname, '../../agent/plugins/agent'),
    path.resolve(__dirname, '../../agent/plugins/windows'),
    path.resolve(__dirname, '../../agent/plugins/linux'),
    path.resolve(__dirname, '../../agent/plugins/mac'),
  ];
  for (const dir of pluginDirs) {
    if (!fs.existsSync(dir)) continue;
    const files = fs.readdirSync(dir);
    for (const file of files) {
      // Only add if not already present
      const name = file;
      const description = 'Auto-synced from plugin directory';
      const version = '1.0.0';
      // Set type based on extension or default to 'binary'
      let type = 'binary';
      if (file.endsWith('.sh')) type = 'script';
      else if (file.endsWith('.js')) type = 'script';
      else if (file.endsWith('.exe')) type = 'binary';
      else if (file.endsWith('.pkg')) type = 'package';
      try {
        await pool.query(
          'INSERT INTO plugins (name, type, description, version) VALUES ($1, $2, $3, $4) ON CONFLICT (name) DO NOTHING',
          [name, type, description, version]
        );
        // Also insert version into agent_versions table if not present
        await pool.query(
          `INSERT INTO agent_versions (version, release_date) VALUES ($1, NOW())
           ON CONFLICT (version) DO NOTHING`,
          [version]
        );
      } catch (err) {
        console.error(`[Plugin Sync] Failed to insert ${name}:`, err.message);
      }
    }
  }
}
 
/**
 * @api {get} /plugins List all available plugins
 * @apiName ListPlugins
 * @apiGroup Plugins
 * @apiDescription Retrieve all available plugins from the database. Optionally sync with plugin directory first to discover new plugin files.
 * @apiParam {boolean} [sync=false] Trigger plugin directory sync before returning list (query param).
 * @apiSuccess {object[]} plugins Array of plugin objects.
 * @apiSuccess {number} plugins.plugin_id Plugin ID.
 * @apiSuccess {string} plugins.name Plugin name.
 * @apiSuccess {string} plugins.type Plugin type (binary, script, package).
 * @apiSuccess {string} plugins.description Plugin description.
 * @apiSuccess {string} plugins.version Plugin version.
 * @apiExample {curl} Example usage:
 *     curl -H "Authorization: Bearer <token>" https://api.example.com/plugins?sync=true
 */
router.get('/', authenticateToken, async (req, res) => {
  try {
    if (req.query.sync === 'true') {
      await syncPluginsWithDb();
    }
    const result = await pool.query('SELECT * FROM plugins ORDER BY name ASC');
    res.json(result.rows);
  } catch (err) {
    console.error('Error fetching plugins:', err);
    res.status(500).json({ error: 'Server error' });
  }
});
 
/**
 * @api {get} /plugins/:agentId/list List plugins for specific agent
 * @apiName ListAgentPlugins
 * @apiGroup Plugins
 * @apiDescription Retrieve list of plugin names available for a specific agent. Auto-syncs plugin directory to ensure current list.
 * @apiParam {string} agentId Agent ID (URL parameter).
 * @apiSuccess {string[]} plugins Array of plugin names.
 * @apiExample {curl} Example usage:
 *     curl -H "Authorization: Bearer <token>" https://api.example.com/plugins/agent-123/list
 */
router.get('/:agentId/list', authenticateToken, async (req, res) => {
  try {
    await syncPluginsWithDb(); // Ensure up-to-date
    const result = await pool.query('SELECT name FROM plugins ORDER BY name ASC');
    res.json(result.rows.map(row => row.name));
  } catch (err) {
    console.error('Error fetching agent plugins:', err);
    res.status(500).json({ error: 'Server error' });
  }
});
 
/**
 * @api {get} /plugins/download/:plugin Download plugin file
 * @apiName DownloadPlugin
 * @apiGroup Plugins
 * @apiDescription Download plugin binary or script file. Searches plugin directories for the requested plugin file and streams it as a download.
 * @apiParam {string} plugin Plugin file name (URL parameter).
 * @apiSuccess {File} file Plugin file for download.
 * @apiError (Error 404) NotFound Plugin not found in database or file not found on disk.
 * @apiExample {curl} Example usage:
 *     curl -H "Authorization: Bearer <token>" -O https://api.example.com/plugins/download/my-plugin.exe
 */
router.get('/download/:plugin', authenticateToken, async (req, res) => {
  try {
    const pluginName = req.params.plugin;
    const result = await pool.query('SELECT name FROM plugins WHERE name = $1', [pluginName]);
    if (result.rows.length === 0) {
      return res.status(404).json({ error: 'Plugin not found' });
    }
    // Try to find file in plugins directory
    const fs = require('fs');
    const path = require('path');
    const pluginDirs = [
      path.resolve(__dirname, '../../agent/plugins/agent'),
      path.resolve(__dirname, '../../agent/plugins/windows'),
      path.resolve(__dirname, '../../agent/plugins/linux'),
      path.resolve(__dirname, '../../agent/plugins/mac'),
    ];
    let filePath = null;
    for (const dir of pluginDirs) {
      const candidate = path.join(dir, pluginName);
      if (fs.existsSync(candidate)) {
        filePath = candidate;
        break;
      }
    }
    if (!filePath) {
      return res.status(404).json({ error: 'Plugin file not found' });
    }
    res.download(filePath);
  } catch (err) {
    console.error('Error downloading plugin:', err);
    res.status(500).json({ error: 'Server error' });
  }
});
 
/**
 * @api {post} /plugins/sync Manually trigger plugin directory sync
 * @apiName SyncPlugins
 * @apiGroup Plugins
 * @apiDescription Scan plugin directories (agent, windows, linux, mac) and sync discovered plugins to database. Creates or updates plugin records and version entries.
 * @apiSuccess {string} status Operation status ("ok" on success).
 * @apiExample {curl} Example usage:
 *     curl -X POST -H "Authorization: Bearer <token>" https://api.example.com/plugins/sync
 */
router.post('/sync', authenticateToken, async (req, res) => {
  try {
    await syncPluginsWithDb();
    res.json({ status: 'ok' });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});
 
/**
 * @api {post} /plugins/initialize/:pluginName/:agentUuid Initialize plugin on agent
 * @apiName InitializePlugin
 * @apiGroup Plugins
 * @apiDescription Initialize a specific plugin on a connected agent via WebSocket or command queue. Plugin must be in allowed_plugins list. Sends initialization command to agent and follows up with status check after 3 seconds.
 * @apiParam {string} pluginName Plugin name (URL parameter).
 * @apiParam {string} agentUuid Agent UUID (URL parameter).
 * @apiSuccess {boolean} success Operation success status.
 * @apiSuccess {string} method Delivery method (websocket, command_queue, fallback).
 * @apiSuccess {string} message Status message.
 * @apiSuccess {string} agentUuid Agent UUID.
 * @apiSuccess {string} pluginName Plugin name.
 * @apiSuccess {object} [command] Command object sent (if WebSocket method).
 * @apiError (Error 400) BadRequest Plugin is not enabled.
 * @apiError (Error 404) NotFound Agent not found.
 * @apiExample {curl} Example usage:
 *     curl -X POST -H "Authorization: Bearer <token>" -H "X-Tenant-ID: <id>" https://api.example.com/plugins/initialize/monitoring/agent-uuid-123
 */
router.post('/initialize/:pluginName/:agentUuid', authenticateToken, setTenantContext, async (req, res) => {
  const { pluginName, agentUuid } = req.params;
  
  try {
    // Verify agent belongs to tenant
    const { clause: tenantClause, params: tenantParams } = getTenantFilter(req, 'a');
    
    let query = `
      SELECT a.agent_uuid, a.hostname, a.status 
      FROM agents a 
      WHERE a.agent_uuid = $1
    `;
    
    let queryParams = [agentUuid];
    
    if (tenantClause) {
      query += ` AND ${tenantClause}`;
      queryParams.push(...tenantParams);
    }
    
    const agentResult = await pool.query(query, queryParams);
    
    if (agentResult.rows.length === 0) {
      return res.status(404).json({ error: 'Agent not found' });
    }
    
    const agent = agentResult.rows[0];
    
    // Check if plugin is allowed
    const pluginResult = await pool.query(
      'SELECT * FROM allowed_plugins WHERE plugin_name = $1',
      [pluginName + '.js'] // Add .js extension
    );
    
    if (pluginResult.rows.length === 0) {
      return res.status(400).json({ error: `Plugin ${pluginName} is not enabled` });
    }
    
    // Try to find agent WebSocket connection
    const ws = wsManager.agentConnections.get(agentUuid);
    
    if (!ws || ws.readyState !== 1) {
      console.log(`[Plugins] WebSocket not found for agent ${agentUuid}, attempting alternative method`);
      
      // Try to queue command for agent to pick up
      try {
        await pool.query(
          `INSERT INTO agent_commands (agent_uuid, command_type, command_data, status, created_at)
           VALUES ($1, $2, $3, 'pending', NOW())
           ON CONFLICT DO NOTHING`,
          [
            agentUuid,
            `${pluginName}_initialize`,
            JSON.stringify({ pluginName, timestamp: Date.now() })
          ]
        );
        
        return res.json({
          success: true,
          method: 'command_queue',
          message: `${pluginName} initialization queued for agent ${agent.hostname}. Agent will process on next check.`,
          agentUuid,
          pluginName
        });
      } catch (cmdError) {
        console.log('[Plugins] Command queue not available, using direct approach');
      }
    }
    
    // Send WebSocket command directly
    const command = {
      type: `${pluginName}_initialize`,
      timestamp: Date.now()
    };
    
    if (ws && ws.readyState === 1) {
      ws.send(JSON.stringify(command));
      console.log(`[Plugins] Sent ${pluginName}_initialize to agent ${agentUuid} (${agent.hostname})`);
      
      // Also send status check after delay
      setTimeout(() => {
        if (ws.readyState === 1) {
          ws.send(JSON.stringify({
            type: `${pluginName}_get_status`,
            timestamp: Date.now()
          }));
          console.log(`[Plugins] Sent ${pluginName}_get_status to agent ${agentUuid}`);
        }
      }, 3000);
      
      return res.json({
        success: true,
        method: 'websocket',
        message: `${pluginName} initialization sent to agent ${agent.hostname}`,
        agentUuid,
        pluginName,
        command
      });
    }
    
    // Fallback: return success anyway, let agent handle it
    res.json({
      success: true,
      method: 'fallback',
      message: `${pluginName} initialization requested for agent ${agent.hostname}. Check agent logs.`,
      agentUuid,
      pluginName
    });
    
  } catch (error) {
    console.error(`[Plugins] Error initializing ${pluginName}:`, error);
    res.status(500).json({ error: 'Failed to initialize plugin', details: error.message });
  }
});
 
/**
 * @api {get} /plugins/status/:agentUuid Get plugin status for agent
 * @apiName GetPluginStatus
 * @apiGroup Plugins
 * @apiDescription Retrieve plugin status for a specific agent including list of enabled plugins and WebSocket connection status. Used to verify agent plugin availability and connectivity.
 * @apiParam {string} agentUuid Agent UUID (URL parameter).
 * @apiSuccess {string} agentUuid Agent UUID.
 * @apiSuccess {string[]} enabledPlugins List of enabled plugin names.
 * @apiSuccess {boolean} wsConnected WebSocket connection status.
 * @apiSuccess {string} hostname Agent hostname.
 * @apiError (Error 404) NotFound Agent not found.
 * @apiExample {curl} Example usage:
 *     curl -H "Authorization: Bearer <token>" -H "X-Tenant-ID: <id>" https://api.example.com/plugins/status/agent-uuid-123
 */
router.get('/status/:agentUuid', authenticateToken, setTenantContext, async (req, res) => {
  const { agentUuid } = req.params;
  
  try {
    // Verify agent belongs to tenant
    const { clause: tenantClause, params: tenantParams } = getTenantFilter(req, 'a');
    
    let query = `
      SELECT a.agent_uuid, a.hostname, a.status 
      FROM agents a 
      WHERE a.agent_uuid = $1
    `;
    
    let queryParams = [agentUuid];
    
    if (tenantClause) {
      query += ` AND ${tenantClause}`;
      queryParams.push(...tenantParams);
    }
    
    const agentResult = await pool.query(query, queryParams);
    
    if (agentResult.rows.length === 0) {
      return res.status(404).json({ error: 'Agent not found' });
    }
    
    // Get enabled plugins
    const pluginsResult = await pool.query('SELECT plugin_name FROM allowed_plugins');
    const enabledPlugins = pluginsResult.rows.map(row => row.plugin_name);
    
    // Check WebSocket connection
    const ws = wsManager.agentConnections.get(agentUuid);
    const wsConnected = ws && ws.readyState === 1;
    
    res.json({
      agentUuid,
      hostname: agentResult.rows[0].hostname,
      agentStatus: agentResult.rows[0].status,
      websocketConnected: wsConnected,
      enabledPlugins,
      connectionMethod: wsConnected ? 'websocket' : 'api_polling'
    });
    
  } catch (error) {
    console.error('[Plugins] Error getting plugin status:', error);
    res.status(500).json({ error: 'Failed to get plugin status', details: error.message });
  }
});
 
module.exports = {
  router,
  syncPluginsWithDb
};