sofarr/server/routes/radarr.js

// Copyright (c) 2026 Gordon Bolton. MIT License.
const express = require('express');
const axios = require('axios');
const router = express.Router();
const requireAuth = require('../middleware/requireAuth');
const sanitizeError = require('../utils/sanitizeError');
const { getWebhookSecret, getSofarrBaseUrl, getRadarrInstances } = require('../utils/config');

// Helper to get first Radarr instance (for notification proxy routes)
function getFirstRadarrInstance() {
  const instances = getRadarrInstances();
  if (!instances || instances.length === 0) {
    return null;
  }
  return instances[0];
}

/**
 * @openapi
 * /api/radarr/queue:
 *   get:
 *     tags: [Radarr]
 *     summary: Get Radarr queue
 *     description: Proxy to Radarr's queue endpoint. Requires authentication and CSRF token.
 *     security:
 *       - CookieAuth: []
 *       - CsrfToken: []
 *     responses:
 *       '200':
 *         description: Queue data from Radarr
 *         content:
 *           application/json:
 *             schema:
 *               type: object
 *       '500':
 *         description: Proxy error
 *         content:
 *           application/json:
 *             schema:
 *               $ref: '#/components/schemas/ErrorResponse'
 */
router.use(requireAuth);

// Get queue
router.get('/queue', async (req, res) => {
  try {
    const response = await axios.get(`${process.env.RADARR_URL}/api/v3/queue`, {
      headers: { 'X-Api-Key': process.env.RADARR_API_KEY }
    });
    res.json(response.data);
  } catch (error) {
    res.status(500).json({ error: 'Failed to fetch Radarr queue', details: sanitizeError(error) });
  }
});

/**
 * @openapi
 * /api/radarr/history:
 *   get:
 *     tags: [Radarr]
 *     summary: Get Radarr history
 *     description: Proxy to Radarr's history endpoint. Requires authentication.
 *     security:
 *       - CookieAuth: []
 *     parameters:
 *       - name: pageSize
 *         in: query
 *         schema:
 *           type: integer
 *           default: 50
 *         description: Number of records per page
 *     responses:
 *       '200':
 *         description: History data from Radarr
 *         content:
 *           application/json:
 *             schema:
 *               type: object
 */
// Get history
router.get('/history', async (req, res) => {
  try {
    const response = await axios.get(`${process.env.RADARR_URL}/api/v3/history`, {
      headers: { 'X-Api-Key': process.env.RADARR_API_KEY },
      params: { pageSize: req.query.pageSize || 50 }
    });
    res.json(response.data);
  } catch (error) {
    res.status(500).json({ error: 'Failed to fetch Radarr history', details: sanitizeError(error) });
  }
});

// Get movie details
router.get('/movies/:id', async (req, res) => {
  try {
    const response = await axios.get(`${process.env.RADARR_URL}/api/v3/movie/${req.params.id}`, {
      headers: { 'X-Api-Key': process.env.RADARR_API_KEY }
    });
    res.json(response.data);
  } catch (error) {
    res.status(500).json({ error: 'Failed to fetch movie details', details: sanitizeError(error) });
  }
});

// Get all movies with tags
router.get('/movies', async (req, res) => {
  try {
    const response = await axios.get(`${process.env.RADARR_URL}/api/v3/movie`, {
      headers: { 'X-Api-Key': process.env.RADARR_API_KEY }
    });
    res.json(response.data);
  } catch (error) {
    res.status(500).json({ error: 'Failed to fetch movies', details: sanitizeError(error) });
  }
});

/**
 * @openapi
 * /api/radarr/notifications/sofarr-webhook:
 *   post:
 *     tags: [Radarr]
 *     summary: Configure Sofarr webhook
 *     description: One-click setup for Sofarr webhook notification in Radarr. Requires authentication and CSRF token.
 *     security:
 *       - CookieAuth: []
 *       - CsrfToken: []
 *     responses:
 *       '200':
 *         description: Configured notification
 *         content:
 *           application/json:
 *             schema:
 *               type: object
 *       '400':
 *         description: Missing configuration
 *         content:
 *           application/json:
 *             schema:
 *               $ref: '#/components/schemas/ErrorResponse'
 *       '503':
 *         description: Radarr not configured
 *         content:
 *           application/json:
 *             schema:
 *               $ref: '#/components/schemas/ErrorResponse'
 */
// Notification proxy routes (Phase 3)
// GET /api/radarr/notifications - list all notifications
router.get('/notifications', async (req, res) => {
  const instance = getFirstRadarrInstance();
  if (!instance) {
    return res.status(503).json({ error: 'Radarr not configured' });
  }
  try {
    const response = await axios.get(`${instance.url}/api/v3/notification`, {
      headers: { 'X-Api-Key': instance.apiKey }
    });
    res.json(response.data);
  } catch (error) {
    console.error('[Radarr] Failed to fetch notifications:', error.message);
    res.status(500).json({ error: 'Failed to fetch Radarr notifications', details: sanitizeError(error) });
  }
});

// GET /api/radarr/notifications/:id - get specific notification
router.get('/notifications/:id', async (req, res) => {
  try {
    const response = await axios.get(`${process.env.RADARR_URL}/api/v3/notification/${req.params.id}`, {
      headers: { 'X-Api-Key': process.env.RADARR_API_KEY }
    });
    res.json(response.data);
  } catch (error) {
    res.status(500).json({ error: 'Failed to fetch Radarr notification', details: sanitizeError(error) });
  }
});

// POST /api/radarr/notifications - create notification
router.post('/notifications', async (req, res) => {
  try {
    const response = await axios.post(`${process.env.RADARR_URL}/api/v3/notification`, req.body, {
      headers: { 'X-Api-Key': process.env.RADARR_API_KEY }
    });
    res.json(response.data);
  } catch (error) {
    res.status(500).json({ error: 'Failed to create Radarr notification', details: sanitizeError(error) });
  }
});

// PUT /api/radarr/notifications/:id - update notification
router.put('/notifications/:id', async (req, res) => {
  try {
    const response = await axios.put(`${process.env.RADARR_URL}/api/v3/notification/${req.params.id}`, req.body, {
      headers: { 'X-Api-Key': process.env.RADARR_API_KEY }
    });
    res.json(response.data);
  } catch (error) {
    res.status(500).json({ error: 'Failed to update Radarr notification', details: sanitizeError(error) });
  }
});

// DELETE /api/radarr/notifications/:id - delete notification
router.delete('/notifications/:id', async (req, res) => {
  try {
    const response = await axios.delete(`${process.env.RADARR_URL}/api/v3/notification/${req.params.id}`, {
      headers: { 'X-Api-Key': process.env.RADARR_API_KEY }
    });
    res.json(response.data);
  } catch (error) {
    res.status(500).json({ error: 'Failed to delete Radarr notification', details: sanitizeError(error) });
  }
});

// POST /api/radarr/notifications/test - test notification
router.post('/notifications/test', async (req, res) => {
  const instance = getFirstRadarrInstance();
  if (!instance) {
    return res.status(503).json({ error: 'Radarr not configured' });
  }
  try {
    const response = await axios.post(`${instance.url}/api/v3/notification/test`, req.body, {
      headers: { 'X-Api-Key': instance.apiKey }
    });
    res.json(response.data);
  } catch (error) {
    console.error('[Radarr] Failed to test notification:', error.message);
    if (error.response) {
      console.error('[Radarr] Test response status:', error.response.status);
      console.error('[Radarr] Test response data:', error.response.data);
    }
    res.status(500).json({ error: 'Failed to test Radarr notification', details: sanitizeError(error) });
  }
});

// GET /api/radarr/notifications/schema - get notification schema
router.get('/notifications/schema', async (req, res) => {
  try {
    const response = await axios.get(`${process.env.RADARR_URL}/api/v3/notification/schema`, {
      headers: { 'X-Api-Key': process.env.RADARR_API_KEY }
    });
    res.json(response.data);
  } catch (error) {
    res.status(500).json({ error: 'Failed to fetch Radarr notification schema', details: sanitizeError(error) });
  }
});

// POST /api/radarr/notifications/sofarr-webhook - one-click Sofarr webhook setup
router.post('/notifications/sofarr-webhook', async (req, res) => {
  const instance = getFirstRadarrInstance();
  if (!instance) {
    return res.status(503).json({ error: 'Radarr not configured' });
  }
  try {
    const sofarrBaseUrl = getSofarrBaseUrl();
    const webhookSecret = getWebhookSecret();

    if (!sofarrBaseUrl) {
      return res.status(400).json({ error: 'SOFARR_BASE_URL not configured' });
    }
    if (!webhookSecret) {
      return res.status(400).json({ error: 'SOFARR_WEBHOOK_SECRET not configured' });
    }

    const webhookUrl = `${sofarrBaseUrl}/api/webhook/radarr`;

    // Check if Sofarr webhook already exists
    const listResponse = await axios.get(`${instance.url}/api/v3/notification`, {
      headers: { 'X-Api-Key': instance.apiKey }
    });
    const existingNotification = listResponse.data.find(n => n.name === 'Sofarr');

    const notificationPayload = {
      name: 'Sofarr',
      implementation: 'Webhook',
      configContract: 'WebhookSettings',
      fields: [
        { name: 'url', value: webhookUrl },
        { name: 'method', value: 1 },
        { name: 'headers', value: [{ key: 'X-Sofarr-Webhook-Secret', value: webhookSecret }] }
      ],
      onGrab: true,
      onDownload: true,
      onUpgrade: true,
      onImport: true,
      onRename: false,
      onHealthIssue: false,
      onApplicationUpdate: false,
      onManualInteractionRequired: false
    };

    if (existingNotification) {
      // Update existing notification
      const response = await axios.put(
        `${instance.url}/api/v3/notification/${existingNotification.id}`,
        { ...notificationPayload, id: existingNotification.id },
        { headers: { 'X-Api-Key': instance.apiKey } }
      );
      res.json(response.data);
    } else {
      // Create new notification
      const response = await axios.post(
        `${instance.url}/api/v3/notification`,
        notificationPayload,
        { headers: { 'X-Api-Key': instance.apiKey } }
      );
      res.json(response.data);
    }
  } catch (error) {
    console.error('[Radarr] Failed to configure webhook:', error.message);
    if (error.response) {
      console.error('[Radarr] Response status:', error.response.status);
      console.error('[Radarr] Response data:', error.response.data);
    }
    res.status(500).json({ error: 'Failed to configure Sofarr webhook', details: sanitizeError(error) });
  }
});

module.exports = router;