agent-v3.js

Go to the documentation of this file.

/**
 * @file agent-v3.js
 * @description Agent v3 white-labeled MeshCentral installer distribution. Provides token-based and authenticated
 * download endpoints for Windows (EXE), Linux (shell script), and macOS (PKG) installers. Proxies requests to
 * MeshCentral server with tenant-specific mesh IDs. Includes installation scripts for automated deployment.
 * @module routes/agent-v3
 */
 
/**
 * @apiDefine AgentV3Group Agent v3 (MeshCentral)
 * White-labeled MeshCentral agent installers
 */
 
/**
 * Agent v3 Download URLs and Installer Management
 * 
 * This route provides white-labeled MeshCentral agent installers
 * branded as "EverydayTech Agent v3"
 */
 
const express = require('express');
const router = express.Router();
const authenticateToken = require('../middleware/auth');
const axios = require('axios');
const jwt = require('jsonwebtoken');
const pool = require('../services/db');
 
const MESHCENTRAL_URL = process.env.MESHCENTRAL_URL || 'https://rmm-psa-meshcentral-aq48h.ondigitalocean.app';
const JWT_SECRET = process.env.JWT_SECRET;
 
/**
 * @api {get} /api/agent-v3/download-token Generate Download Token
 * @apiName GenerateAgentV3DownloadToken
 * @apiGroup AgentV3Group
 * @apiDescription Generates temporary JWT token for agent installer downloads. Token expires in 7 days and is
 * stateless (verified via JWT signature). No authentication required. Use token in /download/:platform/:token endpoints.
 * @apiSuccess {boolean} success Operation status (true)
 * @apiSuccess {string} token JWT download token
 * @apiSuccess {number} expiresIn Token lifetime in seconds (604800)
 * @apiError 500 Token generation failed
 * @apiExample {curl} Example:
 *   curl https://api.example.com/api/agent-v3/download-token
 * @apiExample {json} Success-Response (200):
 *   {"success": true, "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...", "expiresIn": 300}
 */
/**
 * Generate temporary download token (public, rate-limited)
 * GET /api/agent-v3/download-token
 * 
 * Returns a JWT token that expires in 7 days. The token is stateless
 * and verified using JWT signature checking, so it persists across server restarts.
 */
router.get('/download-token', (req, res) => {
  try {
    // Generate JWT token with 7 day expiry
    const token = jwt.sign(
      { purpose: 'agent-download', timestamp: Date.now() },
      JWT_SECRET,
      { expiresIn: '7d' }
    );
    
    res.json({ 
      success: true, 
      token, 
      expiresIn: 604800 // seconds (7 days)
    });
    
  } catch (error) {
    console.error('❌ [AgentV3] Error generating download token:', error);
    res.status(500).json({ error: 'Failed to generate download token' });
  }
});
 
// ====================================================================================
// DOWNLOAD ROUTES - IMPORTANT: Parametrized routes (:token) MUST come before 
// non-parametrized routes to prevent Express from matching /:token as auth route
// ====================================================================================
 
router.get('/download/windows/:token', async (req, res) => {
  try {
    const { token } = req.params;
    const { tenant } = req.query;
    
    console.log(`📥 [AgentV3] Windows download request - Token: ${token.substring(0, 20)}..., Tenant: ${tenant}`);
    
    // Verify JWT signature and expiry (JWT handles expiry automatically)
    let decoded;
    try {
      decoded = jwt.verify(token, JWT_SECRET);
      console.log(`✅ [AgentV3] Token verified - Purpose: ${decoded.purpose}`);
    } catch (err) {
      console.error(`❌ [AgentV3] JWT verification failed:`, err.message);
      return res.status(401).json({ error: 'Invalid or expired download token' });
    }
    
    // Get tenant's MeshCentral group ID
    let meshId = process.env.MESHCENTRAL_DEFAULT_MESH_ID || '';
    if (tenant) {
      try {
        const result = await pool.query(
          'SELECT meshcentral_group_id FROM tenants WHERE tenant_id = $1',
          [tenant]
        );
        if (result.rows.length > 0 && result.rows[0].meshcentral_group_id) {
          meshId = result.rows[0].meshcentral_group_id;
          console.log(`✅ [AgentV3] Windows agent for tenant ${tenant} - mesh: ${meshId.substring(0, 30)}...`);
        } else {
          console.warn(`⚠️  [AgentV3] Tenant ${tenant} has no meshcentral_group_id, using default`);
        }
      } catch (dbErr) {
        console.error(`❌ [AgentV3] DB error fetching mesh ID:`, dbErr.message, dbErr.stack);
        // Continue with default mesh ID
      }
    }
    
    // Download the agent directly from MeshCentral (public endpoint, no auth required)
    const installUrl = `${MESHCENTRAL_URL}/meshagents?id=4&meshid=${meshId}&installflags=0&meshinstall=6`;
    console.log(`🔗 [AgentV3] Fetching from MeshCentral: ${installUrl.substring(0, 100)}...`);
    
    const response = await axios({
      method: 'GET',
      url: installUrl,
      responseType: 'stream',
      headers: {
        'User-Agent': 'EverydayTech-RMM/3.0'
      },
      timeout: 30000, // 30 second timeout
      maxRedirects: 5 // Follow redirects
    });
    
    console.log(`✅ [AgentV3] MeshCentral response received, streaming to client`);
    
    res.setHeader('Content-Type', 'application/octet-stream');
    res.setHeader('Content-Disposition', 'attachment; filename="everydaytech-agent-v3.exe"');
    
    // Handle stream errors
    response.data.on('error', (streamErr) => {
      console.error(`❌ [AgentV3] Stream error:`, streamErr.message);
    });
    
    response.data.pipe(res);
    
  } catch (error) {
    console.error('❌ [AgentV3] Error downloading Windows agent:', error.message);
    console.error('Stack:', error.stack);
    if (!res.headersSent) {
      res.status(500).json({ error: 'Failed to download installer', details: error.message });
    }
  }
});
 
/**
 * @api {get} /api/agent-v3/download/linux/:token Download Linux Installer (Token)
 * @apiName DownloadLinuxAgentToken
 * @apiGroup AgentV3Group
 * @apiDescription Downloads Linux shell script installer using temporary token. Authenticates with MeshCentral admin
 * credentials, fetches tenant-specific mesh ID if tenant parameter provided, and returns bash installation script.
 * Token expires in 7 days.
 * @apiParam {string} token Download token from /download-token endpoint
 * @apiParam (Query) {UUID} [tenant] Tenant UUID for mesh-specific installer
 * @apiSuccess (200) {String} script Linux installation shell script (text/plain)
 * @apiError 401 Invalid or expired token
 * @apiError 500 MeshCentral authentication/download error
 * @apiExample {curl} Example:
 *   curl "https://api.example.com/api/agent-v3/download/linux/eyJhbGc...?tenant=550e8400-e29b-41d4-a716-446655440000" \
 *     | sudo bash
 */
/**
 * Download Linux agent with temporary token
 * GET /api/agent-v3/download/linux/:token
 
router.get('/download/windows', authenticateToken, async (req, res) => {
  try {
    const meshId = process.env.MESHCENTRAL_DEFAULT_MESH_ID || '';
    const installUrl = `${MESHCENTRAL_URL}/meshagents?id=4&meshid=${meshId}&installflags=0&meshinstall=6`;
 
    // Stream the installer from MeshCentral to the client
    const response = await axios({
      method: 'GET',
      url: installUrl,
      responseType: 'stream',
      // MeshCentral may require these headers
      headers: {
        'User-Agent': 'EverydayTech-RMM/3.0'
      }
    });
 
    // Set appropriate headers for download
    res.setHeader('Content-Type', 'application/octet-stream');
    res.setHeader('Content-Disposition', 'attachment; filename="everydaytech-agent-v3.exe"');
 
    // Pipe the response
    response.data.pipe(res);
 
  } catch (error) {
    console.error('❌ [AgentV3] Error proxying Windows installer:', error.message);
    res.status(500).json({ 
      error: 'Failed to download installer', 
      details: error.message 
    });
  }
});
 
/**
 * @api {get} /api/agent-v3/download/linux Download Linux Installer (Auth)
 * @apiName DownloadLinuxAgentAuth
 * @apiGroup AgentV3Group
 * @apiDescription Proxies Linux shell script installer from MeshCentral with JWT authentication. Returns bash script
 * as text/plain. Requires valid Bearer token.
 * @apiSuccess (200) {String} script Linux installation shell script (text/plain)
 * @apiError 401 Authentication required
 * @apiError 500 MeshCentral proxy error
 * @apiExample {curl} Example:
 *   curl https://api.example.com/api/agent-v3/download/linux \
 *     -H "Authorization: Bearer YOUR_TOKEN" | sudo bash
 */
/**
 * Proxy download endpoint for Linux agent script (JWT authenticated)
 * GET /api/agent-v3/download/linux
 
router.get('/download/linux/:token', async (req, res) => {
  try {
    const { token } = req.params;
    const { tenant } = req.query;
 
    console.log(`📥 [AgentV3] Linux download request - Token: ${token.substring(0, 20)}..., Tenant: ${tenant}`);
 
    // Verify JWT signature and expiry
    let decoded;
    try {
      decoded = jwt.verify(token, JWT_SECRET);
      console.log(`✅ [AgentV3] Token verified - Purpose: ${decoded.purpose}`);
    } catch (err) {
      console.error(`❌ [AgentV3] JWT verification failed:`, err.message);
      return res.status(401).send('#!/bin/bash\necho "Error: Invalid or expired download token"');
    }
 
    // Get tenant's MeshCentral group ID
    let meshId = process.env.MESHCENTRAL_DEFAULT_MESH_ID || '';
    if (tenant) {
      try {
        const result = await pool.query(
          'SELECT meshcentral_group_id FROM tenants WHERE tenant_id = $1',
          [tenant]
        );
        if (result.rows.length > 0 && result.rows[0].meshcentral_group_id) {
          meshId = result.rows[0].meshcentral_group_id;
          console.log(`✅ [AgentV3] Linux agent for tenant ${tenant} - mesh: ${meshId.substring(0, 30)}...`);
        } else {
          console.warn(`⚠️  [AgentV3] Tenant ${tenant} has no meshcentral_group_id, using default`);
        }
      } catch (dbErr) {
        console.error(`❌ [AgentV3] DB error fetching mesh ID:`, dbErr.message, dbErr.stack);
      }
    }
 
    // Download the agent directly from MeshCentral (public endpoint, no auth required)
    const installUrl = `${MESHCENTRAL_URL}/meshagents?script=1&id=4&meshid=${meshId}&installflags=0`;
    console.log(`🔗 [AgentV3] Fetching from MeshCentral: ${installUrl.substring(0, 100)}...`);
 
    const response = await axios({
      method: 'GET',
      url: installUrl,
      headers: {
        'User-Agent': 'EverydayTech-RMM/3.0'
      },
      timeout: 30000,
      maxRedirects: 5 // Follow redirects
    });
 
    console.log(`✅ [AgentV3] MeshCentral response received, sending to client`);
 
    res.type('text/plain');
    res.send(response.data);
 
  } catch (error) {
    console.error('❌ [AgentV3] Error downloading Linux agent:', error.message);
    console.error('Stack:', error.stack);
    if (!res.headersSent) {
      res.status(500).send('#!/bin/bash\necho "Error: Failed to download installer"');
    }
  }
});
 
/**
 * @api {get} /api/agent-v3/download/macos/:token Download macOS Installer (Token)
 * @apiName DownloadMacOSAgentToken
 * @apiGroup AgentV3Group
 * @apiDescription Downloads macOS PKG installer using temporary token. Authenticates with MeshCentral admin credentials,
 * fetches tenant-specific mesh ID if tenant parameter provided, and streams package file. Token expires in 7 days.
 * @apiParam {string} token Download token from /download-token endpoint
 * @apiParam (Query) {UUID} [tenant] Tenant UUID for mesh-specific installer
 * @apiSuccess (200) {Binary} pkg macOS installer package (application/octet-stream)
 * @apiError 401 Invalid or expired token
 * @apiError 500 MeshCentral authentication/download error
 * @apiExample {curl} Example:
 *   curl "https://api.example.com/api/agent-v3/download/macos/eyJhbGc...?tenant=550e8400-e29b-41d4-a716-446655440000" \
 *     -o everydaytech-agent-v3.pkg
 */
/**
 * Download macOS agent with temporary token
 * GET /api/agent-v3/download/macos/:token
 
router.get('/download/linux', authenticateToken, async (req, res) => {
  try {
    const meshId = process.env.MESHCENTRAL_DEFAULT_MESH_ID || '';
    const installUrl = `${MESHCENTRAL_URL}/meshagents?script=1&id=4&meshid=${meshId}&installflags=0`;
 
    const response = await axios({
      method: 'GET',
      url: installUrl,
      headers: {
        'User-Agent': 'EverydayTech-RMM/3.0'
      }
    });
 
    res.type('text/plain');
    res.send(response.data);
 
  } catch (error) {
    console.error('❌ [AgentV3] Error proxying Linux installer:', error.message);
    res.status(500).send('#!/bin/bash\necho "Error: Failed to download installer"');
  }
});
 
/**
 * @api {get} /api/agent-v3/download/macos Download macOS Installer (Auth)
 * @apiName DownloadMacOSAgentAuth
 * @apiGroup AgentV3Group
 * @apiDescription Proxies macOS PKG installer from MeshCentral with JWT authentication. Streams package file to
 * client with "everydaytech-agent-v3.pkg" filename. Requires valid Bearer token.
 * @apiSuccess (200) {Binary} pkg macOS installer package (application/octet-stream)
 * @apiError 401 Authentication required
 * @apiError 500 MeshCentral proxy error
 * @apiExample {curl} Example:
 *   curl https://api.example.com/api/agent-v3/download/macos \
 *     -H "Authorization: Bearer YOUR_TOKEN" \
 *     -o everydaytech-agent-v3.pkg
 */
/**
 * Proxy download endpoint for macOS agent (JWT authenticated)
 * GET /api/agent-v3/download/macos
 
router.get('/download/macos/:token', async (req, res) => {
  try {
    const { token } = req.params;
    const { tenant } = req.query;
 
    console.log(`📥 [AgentV3] macOS download request - Token: ${token.substring(0, 20)}..., Tenant: ${tenant}`);
 
    // Verify JWT signature and expiry
    let decoded;
    try {
      decoded = jwt.verify(token, JWT_SECRET);
      console.log(`✅ [AgentV3] Token verified - Purpose: ${decoded.purpose}`);
    } catch (err) {
      console.error(`❌ [AgentV3] JWT verification failed:`, err.message);
      return res.status(401).json({ error: 'Invalid or expired download token' });
    }
 
    // Get tenant's MeshCentral group ID
    let meshId = process.env.MESHCENTRAL_DEFAULT_MESH_ID || '';
    if (tenant) {
      try {
        const result = await pool.query(
          'SELECT meshcentral_group_id FROM tenants WHERE tenant_id = $1',
          [tenant]
        );
        if (result.rows.length > 0 && result.rows[0].meshcentral_group_id) {
          meshId = result.rows[0].meshcentral_group_id;
          console.log(`✅ [AgentV3] macOS agent for tenant ${tenant} - mesh: ${meshId.substring(0, 30)}...`);
        } else {
          console.warn(`⚠️  [AgentV3] Tenant ${tenant} has no meshcentral_group_id, using default`);
        }
      } catch (dbErr) {
        console.error(`❌ [AgentV3] DB error fetching mesh ID:`, dbErr.message, dbErr.stack);
      }
    }
 
    // Download the agent directly from MeshCentral (public endpoint, no auth required)
    const installUrl = `${MESHCENTRAL_URL}/meshagents?id=4&meshid=${meshId}&installflags=0&meshinstall=16`;
    console.log(`🔗 [AgentV3] Fetching from MeshCentral: ${installUrl.substring(0, 100)}...`);
 
    const response = await axios({
      method: 'GET',
      url: installUrl,
      responseType: 'stream',
      headers: {
        'User-Agent': 'EverydayTech-RMM/3.0'
      },
      timeout: 30000,
      maxRedirects: 5 // Follow redirects
    });
 
    console.log(`✅ [AgentV3] MeshCentral response received, streaming to client`);
 
    res.setHeader('Content-Type', 'application/octet-stream');
    res.setHeader('Content-Disposition', 'attachment; filename="everydaytech-agent-v3.pkg"');
 
    // Handle stream errors
    response.data.on('error', (streamErr) => {
      console.error(`❌ [AgentV3] Stream error:`, streamErr.message);
    });
 
    response.data.pipe(res);
 
  } catch (error) {
    console.error('❌ [AgentV3] Error downloading macOS agent:', error.message);
    console.error('Stack:', error.stack);
    if (!res.headersSent) {
      res.status(500).json({ error: 'Failed to download installer', details: error.message });
    }
  }
});
 
/**
 * @api {get} /api/agent-v3/downloads Get Download URLs
 * @apiName GetAgentV3DownloadURLs
 * @apiGroup AgentV3Group
 * @apiDescription Returns authenticated download URLs for all platforms and architectures. Includes installation
 * instructions and MeshCentral server metadata. Requires JWT authentication.
 * @apiSuccess {boolean} success Operation status (true)
 * @apiSuccess {string} meshcentralUrl MeshCentral server URL
 * @apiSuccess {string} meshId Default mesh ID
 * @apiSuccess {object} downloads Platform-specific download URLs
 * @apiSuccess {object} downloads.windows Windows download options
 * @apiSuccess {object} downloads.windows.x64 64-bit Windows installer URL
 * @apiSuccess {object} downloads.linux Linux download options
 * @apiSuccess {object} downloads.macos macOS download options
 * @apiSuccess {Object} instructions Platform-specific installation instructions
 * @apiError 401 Authentication required
 * @apiError 500 Server error
 * @apiExample {curl} Example:
 *   curl https://api.example.com/api/agent-v3/downloads \
 *     -H "Authorization: Bearer YOUR_TOKEN"
 * @apiExample {json} Success-Response (200):
 *   {
 *     "success": true,
 *     "meshcentralUrl": "https://mesh.example.com",
 *     "downloads": {
 *       "windows": {"x64": {"exe": "https://api.example.com/api/agent-v3/download/windows", "name": "EverydayTech Agent v3 (Windows 64-bit)"}}
 *     },
 *     "instructions": {"windows": "Run the .exe or .msi installer as Administrator"}
 *   }
 */
/**
 * Get agent download URLs for all platforms
 * GET /api/agent-v3/downloads
 
router.get('/download/macos', authenticateToken, async (req, res) => {
  try {
    const meshId = process.env.MESHCENTRAL_DEFAULT_MESH_ID || '';
    const installUrl = `${MESHCENTRAL_URL}/meshagents?id=4&meshid=${meshId}&installflags=0&meshinstall=16`;
 
    const response = await axios({
      method: 'GET',
      url: installUrl,
      responseType: 'stream',
      headers: {
        'User-Agent': 'EverydayTech-RMM/3.0'
      }
    });
 
    res.setHeader('Content-Type', 'application/octet-stream');
    res.setHeader('Content-Disposition', 'attachment; filename="everydaytech-agent-v3.pkg"');
    response.data.pipe(res);
 
  } catch (error) {
    console.error('❌ [AgentV3] Error proxying macOS installer:', error.message);
    res.status(500).json({ error: 'Failed to download installer' });
  }
});
 
/**
 * @api {get} /api/agent-v3/download/windows/:token Download Windows Installer (Token)
 * @apiName DownloadWindowsAgentToken
 * @apiGroup AgentV3Group
 * @apiDescription Downloads Windows EXE installer using temporary token from /download-token endpoint. Authenticates
 * with MeshCentral admin credentials, fetches tenant-specific mesh ID from database if tenant query parameter provided,
 * and streams installer binary. Token expires in 7 days. Logs detailed operation trace for debugging.
 * @apiParam {string} token Download token from /download-token endpoint
 * @apiParam (Query) {UUID} [tenant] Tenant UUID for mesh-specific installer
 * @apiSuccess (200) {Binary} exe Windows installer binary (application/octet-stream)
 * @apiError 401 Invalid or expired token
 * @apiError 500 MeshCentral authentication/download error
 * @apiExample {curl} Example:
 *   curl "https://api.example.com/api/agent-v3/download/windows/eyJhbGc...?tenant=550e8400-e29b-41d4-a716-446655440000" \
 *     -o everydaytech-agent-v3.exe
 */
/**
 * Download Windows agent with temporary token
 * GET /api/agent-v3/download/windows/:token
 
 */
router.get('/downloads', authenticateToken, async (req, res) => {
  try {
    // MeshCentral agent download URLs
    // Proxied through our backend with JWT authentication
    
    const backendUrl = process.env.BACKEND_URL || 'https://rmm-psa-backend-t9f7k.ondigitalocean.app';
    
    const downloads = {
      windows: {
        x64: {
          exe: `${backendUrl}/api/agent-v3/download/windows`,
          msi: `${backendUrl}/api/agent-v3/download/windows`,
          name: 'EverydayTech Agent v3 (Windows 64-bit)'
        },
        x86: {
          exe: `${backendUrl}/api/agent-v3/download/windows`,
          name: 'EverydayTech Agent v3 (Windows 32-bit)'
        }
      },
      linux: {
        x64: {
          sh: `${backendUrl}/api/agent-v3/download/linux`,
          name: 'EverydayTech Agent v3 (Linux 64-bit)'
        },
        arm: {
          sh: `${backendUrl}/api/agent-v3/download/linux`,
          name: 'EverydayTech Agent v3 (Linux ARM)'
        }
      },
      macos: {
        x64: {
          pkg: `${backendUrl}/api/agent-v3/download/macos`,
          name: 'EverydayTech Agent v3 (macOS Intel)'
        },
        arm64: {
          pkg: `${backendUrl}/api/agent-v3/download/macos`,
          name: 'EverydayTech Agent v3 (macOS Apple Silicon)'
        }
      }
    };
    
    res.json({
      success: true,
      meshcentralUrl: MESHCENTRAL_URL,
      meshId: meshId,
      downloads: downloads,
      instructions: {
        windows: 'Run the .exe or .msi installer as Administrator',
        linux: 'Download and run: wget -O install.sh [URL] && sudo bash install.sh',
        macos: 'Download the .pkg file and double-click to install'
      }
    });
    
  } catch (error) {
    console.error('❌ [AgentV3] Error getting downloads:', error);
    res.status(500).json({ error: 'Failed to get agent downloads' });
  }
});
 
/**
 * @api {get} /api/agent-v3/install-script Get Linux/macOS Install Script
 * @apiName GetAgentV3InstallScript
 * @apiGroup AgentV3Group
 * @apiDescription Returns bash installation script for Linux/macOS. Script generates temporary download token,
 * downloads installer from /download/linux/:token endpoint, and executes with sudo. No authentication required.
 * @apiSuccess (200) {String} script Bash installation script (text/plain)
 * @apiError 500 Script generation error
 * @apiExample {curl} Example:
 *   curl https://api.example.com/api/agent-v3/install-script | sudo bash
 */
/**
 * Get agent installation script for Linux/Mac
 * GET /api/agent-v3/install-script
 */
router.get('/install-script', async (req, res) => {
  try {
    const backendUrl = process.env.BACKEND_URL || 'https://rmm-psa-backend-t9f7k.ondigitalocean.app';
    
    res.type('text/plain');
    res.send(`#!/bin/bash
# EverydayTech Agent v3 Installation Script
# 
# This script downloads and installs the EverydayTech RMM Agent
# The agent will appear in your dashboard: https://everydaytech.au
 
echo "🚀 Installing EverydayTech Agent v3..."
echo ""
 
# Get temporary download token
echo "Getting download token..."
TOKEN_RESPONSE=$(curl -s "${backendUrl}/api/agent-v3/download-token")
TOKEN=$(echo $TOKEN_RESPONSE | grep -o '"token":"[^"]*' | cut -d'"' -f4)
 
if [ -z "$TOKEN" ]; then
  echo "❌ Failed to get download token"
  exit 1
fi
 
# Download and run the installer
echo "Downloading installer..."
wget -qO- "${backendUrl}/api/agent-v3/download/linux/$TOKEN" | sudo bash
 
if [ $? -eq 0 ]; then
  echo ""
  echo "✅ EverydayTech Agent v3 installed successfully!"
  echo "   The agent will appear in your dashboard within 30 seconds."
  echo "   Dashboard: https://everydaytech.au"
else
  echo ""
  echo "❌ Installation failed. Please check the error messages above."
  exit 1
fi
`);
    
  } catch (error) {
    console.error('❌ [AgentV3] Error generating install script:', error);
    res.status(500).send('# Error generating install script');
  }
});
 
/**
 * @api {get} /api/agent-v3/install-script/windows Get Windows PowerShell Install Script
 * @apiName GetAgentV3WindowsInstallScript
 * @apiGroup AgentV3Group
 * @apiDescription Returns PowerShell installation script for Windows. Script generates temporary download token,
 * downloads EXE to %TEMP%, executes with silent flag (/S), checks service status, and cleans up. No authentication required.
 * @apiSuccess (200) {String} script PowerShell installation script (text/plain)
 * @apiError 500 Script generation error
 * @apiExample {powershell} Example:
 *   iwr -useb https://api.example.com/api/agent-v3/install-script/windows | iex
 */
/**
 * Get Windows PowerShell installation script
 * GET /api/agent-v3/install-script/windows
 */
router.get('/install-script/windows', async (req, res) => {
  try {
    const backendUrl = process.env.BACKEND_URL || 'https://rmm-psa-backend-t9f7k.ondigitalocean.app';
    
    res.type('text/plain');
    res.send(`# EverydayTech Agent v3 Installation Script (Windows)
# 
# Run this in PowerShell as Administrator:
# iwr -useb https://rmm-psa-backend-t9f7k.ondigitalocean.app/api/agent-v3/install-script/windows | iex
 
Write-Host "🚀 Installing EverydayTech Agent v3..." -ForegroundColor Cyan
Write-Host ""
 
# Get temporary download token
Write-Host "Getting download token..."
$tokenResponse = Invoke-RestMethod -Uri "${backendUrl}/api/agent-v3/download-token"
$token = $tokenResponse.token
 
if (-not $token) {
    Write-Host "❌ Failed to get download token" -ForegroundColor Red
    exit 1
}
 
# Download installer
$installerPath = "$env:TEMP\\everydaytech-agent-v3.exe"
Write-Host "Downloading installer..."
Invoke-WebRequest -Uri "${backendUrl}/api/agent-v3/download/windows/$token" -OutFile $installerPath
 
# Run installer
Write-Host "Running installer..."
Start-Process -FilePath $installerPath -ArgumentList "/S" -Wait
 
# Check if service is running
$service = Get-Service -Name "EverydayTechAgent" -ErrorAction SilentlyContinue
if ($service -and $service.Status -eq "Running") {
    Write-Host ""
    Write-Host "✅ EverydayTech Agent v3 installed successfully!" -ForegroundColor Green
    Write-Host "   The agent will appear in your dashboard within 30 seconds." -ForegroundColor Green
    Write-Host "   Dashboard: https://everydaytech.au" -ForegroundColor Cyan
} else {
    Write-Host ""
    Write-Host "⚠️  Installation completed but service may not be running." -ForegroundColor Yellow
    Write-Host "   Please check Windows Services for 'EverydayTech Agent'" -ForegroundColor Yellow
}
 
# Clean up
Remove-Item $installerPath -Force -ErrorAction SilentlyContinue
`);
    
  } catch (error) {
    console.error('❌ [AgentV3] Error generating Windows install script:', error);
    res.status(500).send('# Error generating install script');
  }
});
 
/**
 * @api {get} /api/agent-v3/config Get Agent v3 Configuration
 * @apiName GetAgentV3Config
 * @apiGroup AgentV3Group
 * @apiDescription Returns agent v3 configuration including MeshCentral server URL, default mesh ID, version, and
 * feature list (remote desktop, terminal access, file transfer, hardware inventory, auto-updates, cross-platform,
 * real-time status, event logging). Requires JWT authentication.
 * @apiSuccess {boolean} success Operation status (true)
 * @apiSuccess {string} meshcentralUrl MeshCentral server URL
 * @apiSuccess {string} meshId Default mesh ID
 * @apiSuccess {string} version Agent version ("3.0.0")
 * @apiSuccess {string[]} features Feature list
 * @apiError 401 Authentication required
 * @apiError 500 Server error
 * @apiExample {curl} Example:
 *   curl https://api.example.com/api/agent-v3/config \
 *     -H "Authorization: Bearer YOUR_TOKEN"
 * @apiExample {json} Success-Response (200):
 *   {
 *     "success": true,
 *     "meshcentralUrl": "https://mesh.example.com",
 *     "meshId": "mesh/abc123...",
 *     "version": "3.0.0",
 *     "features": ["Remote Desktop (High Performance)", "Terminal/SSH Access", "File Transfer"]
 *   }
 */
/**
 * Get agent configuration info
 * GET /api/agent-v3/config
 */
router.get('/config', authenticateToken, async (req, res) => {
  try {
    res.json({
      success: true,
      meshcentralUrl: MESHCENTRAL_URL,
      meshId: process.env.MESHCENTRAL_DEFAULT_MESH_ID || 'Not configured',
      version: '3.0.0',
      features: [
        'Remote Desktop (High Performance)',
        'Terminal/SSH Access',
        'File Transfer',
        'System Information Collection',
        'Hardware Inventory',
        'Auto-Updates',
        'Cross-Platform (Windows, Linux, macOS)',
        'Real-time Connection Status',
        'Event Logging'
      ],
      setupRequired: !process.env.MESHCENTRAL_DEFAULT_MESH_ID,
      setupInstructions: 'Login to MeshCentral, create a device group, and add MESHCENTRAL_DEFAULT_MESH_ID to environment variables'
    });
  } catch (error) {
    console.error('❌ [AgentV3] Error getting config:', error);
    res.status(500).json({ error: 'Failed to get agent config' });
  }
});
 
module.exports = router;