agent-download.js

Go to the documentation of this file.

/**
 * @file agent-download.js
 * @description Agent v2 download proxy service. Fetches agent installers from GitHub Releases API and redirects
 * clients to platform-specific assets. Requires GITHUB_TOKEN environment variable for private repositories.
 * Supports Windows/Linux/macOS platforms with automatic asset pattern matching.
 * @module routes/agent-download
 */
 
/**
 * @apiDefine AgentDownloadGroup Agent Downloads (v2)
 * Agent installer downloads from GitHub releases
 */
 
// routes/agent-download.js
// Handle agent downloads from GitHub Releases
 
const express = require('express');
const router = express.Router();
const fetch = require('node-fetch');
 
// GitHub configuration
const GITHUB_ORG = process.env.GITHUB_ORG || 'Independent-Business-Group';
const GITHUB_REPO = process.env.GITHUB_AGENT_REPO || 'rmm-psa-agent-v2';
const GITHUB_TOKEN = process.env.GITHUB_TOKEN; // Optional, for private repos
 
// Get the latest release from GitHub
/**
 *
 */
async function getLatestRelease() {
  const url = `https://api.github.com/repos/${GITHUB_ORG}/${GITHUB_REPO}/releases/latest`;
  const headers = {
    'Accept': 'application/vnd.github.v3+json',
    'User-Agent': 'RMM-PSA-Backend'
  };
  
  if (GITHUB_TOKEN) {
    headers['Authorization'] = `token ${GITHUB_TOKEN}`;
  }
  
  try {
    const response = await fetch(url, { headers });
    if (!response.ok) {
      throw new Error(`GitHub API returned ${response.status}: ${response.statusText}`);
    }
    return await response.json();
  } catch (err) {
    console.error('[Agent Download] Failed to fetch latest release:', err.message);
    throw err;
  }
}
 
// Get download URL for specific platform
/**
 *
 * @param release
 * @param platform
 */
function getDownloadUrl(release, platform) {
  const assets = release.assets || [];
  
  // Map platform to asset name patterns
  const patterns = {
    'windows': /win.*\.(exe|zip)$/i,
    'linux': /linux.*$/i,
    'macos': /macos.*$/i,
    'darwin': /macos.*$/i
  };
  
  const pattern = patterns[platform.toLowerCase()];
  if (!pattern) {
    throw new Error(`Unknown platform: ${platform}`);
  }
  
  const asset = assets.find(a => pattern.test(a.name));
  if (!asset) {
    throw new Error(`No asset found for platform: ${platform}`);
  }
  
  return {
    url: asset.browser_download_url,
    name: asset.name,
    size: asset.size,
    downloadCount: asset.download_count
  };
}
 
/**
 * @api {get} /api/agent/download/:platform Download Agent Installer
 * @apiName DownloadAgentInstaller
 * @apiGroup AgentDownloadGroup
 * @apiDescription Fetches latest agent installer from GitHub Releases and redirects to download URL. Supports
 * platform-specific asset matching (Windows: .exe/.zip, Linux: linux binaries, macOS: macos binaries).
 * @apiParam {string} platform Platform identifier (windows, linux, macos, darwin)
 * @apiSuccess (302) Redirect Redirects to GitHub asset download URL
 * @apiError 500 GitHub API error or asset not found
 * @apiExample {curl} Example:
 *   curl -L https://api.example.com/api/agent/download/windows -o agent-installer.exe
 * @apiExample {json} Error-Response (500):
 *   {"error":"Failed to fetch agent download", "message":"No asset found for platform: linux", "platform":"linux"}
 */
// GET /api/agent/download/:platform
// Redirects to the latest agent download for the specified platform
router.get('/download/:platform', async (req, res) => {
  const platform = req.params.platform;
  
  try {
    console.log(`[Agent Download] Request for platform: ${platform}`);
    
    const release = await getLatestRelease();
    console.log(`[Agent Download] Latest release: ${release.tag_name} (${release.name})`);
    
    const download = getDownloadUrl(release, platform);
    console.log(`[Agent Download] Redirecting to: ${download.name} (${(download.size / 1024 / 1024).toFixed(2)} MB)`);
    
    // Redirect to GitHub's download URL
    res.redirect(302, download.url);
    
  } catch (err) {
    console.error('[Agent Download] Error:', err.message);
    res.status(500).json({ 
      error: 'Failed to fetch agent download',
      message: err.message,
      platform
    });
  }
});
 
/**
 * @api {get} /api/agent/info Get Release Info
 * @apiName GetAgentReleaseInfo
 * @apiGroup AgentDownloadGroup
 * @apiDescription Retrieves detailed information about latest GitHub release including version, notes, and
 * platform-specific download URLs with asset metadata (filename, size, download count).
 * @apiSuccess {string} version Release tag (e.g., "v2.0.0")
 * @apiSuccess {string} name Release name
 * @apiSuccess {string} published ISO 8601 publication timestamp
 * @apiSuccess {string} notes Release notes/changelog (Markdown)
 * @apiSuccess {object} platforms Platform-specific download metadata
 * @apiSuccess {object} platforms.windows Windows installer details
 * @apiSuccess {boolean} platforms.windows.available Asset availability
 * @apiSuccess {string} platforms.windows.filename Asset filename
 * @apiSuccess {number} platforms.windows.size File size in bytes
 * @apiSuccess {number} platforms.windows.downloadCount GitHub download count
 * @apiSuccess {string} platforms.windows.downloadUrl Backend proxy download URL
 * @apiSuccess {string} githubUrl GitHub release page URL
 * @apiError 500 GitHub API error
 * @apiExample {curl} Example:
 *   curl https://api.example.com/api/agent/info
 * @apiExample {json} Success-Response (200):
 *   {
 *     "version": "v2.0.0",
 *     "name": "Agent v2.0.0 - Stable Release",
 *     "published": "2026-01-15T10:30:00Z",
 *     "notes": "# Changes\n- Fixed RDP connection\n- Added Linux support",
 *     "platforms": {
 *       "windows": {"available": true, "filename": "agent-win-x64.exe", "size": 8421376, "downloadCount": 42},
 *       "linux": {"available": true, "filename": "agent-linux-x64", "size": 7340032, "downloadCount": 15}
 *     },
 *     "githubUrl": "https://github.com/org/repo/releases/tag/v2.0.0"
 *   }
 */
// GET /api/agent/info
// Returns information about the latest release
router.get('/info', async (req, res) => {
  try {
    const release = await getLatestRelease();
    
    const platforms = {};
    ['windows', 'linux', 'macos'].forEach(platform => {
      try {
        const download = getDownloadUrl(release, platform);
        platforms[platform] = {
          available: true,
          filename: download.name,
          size: download.size,
          downloadCount: download.downloadCount,
          downloadUrl: `/api/releases/download/${platform}`
        };
      } catch (err) {
        platforms[platform] = {
          available: false,
          error: err.message
        };
      }
    });
    
    res.json({
      version: release.tag_name,
      name: release.name,
      published: release.published_at,
      notes: release.body,
      platforms,
      githubUrl: release.html_url
    });
    
  } catch (err) {
    console.error('[Agent Info] Error:', err.message);
    res.status(500).json({ 
      error: 'Failed to fetch release information',
      message: err.message
    });
  }
});
 
/**
 * @api {get} /api/agent/versions List All Versions
 * @apiName ListAgentVersions
 * @apiGroup AgentDownloadGroup
 * @apiDescription Retrieves all available GitHub releases with metadata. Includes prerelease and draft flags.
 * @apiSuccess {object[]} versions Array of release objects
 * @apiSuccess {string} versions.version Release tag
 * @apiSuccess {string} versions.name Release name
 * @apiSuccess {string} versions.published ISO 8601 publication timestamp
 * @apiSuccess {boolean} versions.prerelease Prerelease flag
 * @apiSuccess {boolean} versions.draft Draft flag
 * @apiSuccess {string} versions.url GitHub release page URL
 * @apiError 500 GitHub API error
 * @apiExample {curl} Example:
 *   curl https://api.example.com/api/agent/versions
 * @apiExample {json} Success-Response (200):
 *   {
 *     "versions": [
 *       {"version":"v2.0.0", "name":"Stable", "published":"2026-01-15T10:30:00Z", "prerelease":false, "draft":false},
 *       {"version":"v2.0.0-rc1", "name":"Beta", "published":"2026-01-10T08:00:00Z", "prerelease":true, "draft":false}
 *     ]
 *   }
 */
// GET /api/agent/versions
// Returns all available versions
router.get('/versions', async (req, res) => {
  const url = `https://api.github.com/repos/${GITHUB_ORG}/${GITHUB_REPO}/releases`;
  const headers = {
    'Accept': 'application/vnd.github.v3+json',
    'User-Agent': 'RMM-PSA-Backend'
  };
  
  if (GITHUB_TOKEN) {
    headers['Authorization'] = `token ${GITHUB_TOKEN}`;
  }
  
  try {
    const response = await fetch(url, { headers });
    if (!response.ok) {
      throw new Error(`GitHub API returned ${response.status}`);
    }
    
    const releases = await response.json();
    
    const versions = releases.map(r => ({
      version: r.tag_name,
      name: r.name,
      published: r.published_at,
      prerelease: r.prerelease,
      draft: r.draft,
      url: r.html_url
    }));
    
    res.json({ versions });
    
  } catch (err) {
    console.error('[Agent Versions] Error:', err.message);
    res.status(500).json({ 
      error: 'Failed to fetch versions',
      message: err.message
    });
  }
});
 
module.exports = router;