radarr_review_setup

Instructions

Implementation Reference

• src/index.ts:188-197 (registration)

  The 'radarr_review_setup' tool is registered via the addConfigTools('radarr', 'Radarr (Movies)') call at line 202. The generic tool template is defined in the addConfigTools function (lines 132-198), which creates the tool with name `${serviceName}_review_setup`. For radarr, this produces 'radarr_review_setup'. The tool has no input parameters and promises a comprehensive configuration review.

    {
      name: `${serviceName}_review_setup`,
      description: `Get comprehensive configuration review for ${displayName}. Returns all settings for analysis: quality profiles, download clients, naming, storage, indexers, health warnings, and more. Use this to analyze the setup and suggest improvements.`,
      inputSchema: {
        type: "object" as const,
        properties: {},
        required: [],
      },
    }
  );

• src/index.ts:201-202 (registration)

  Conditional registration call: 'if (clients.radarr) addConfigTools('radarr', 'Radarr (Movies)')' at line 202 triggers the creation of 'radarr_review_setup' along with other Radarr config tools.

  if (clients.sonarr) addConfigTools('sonarr', 'Sonarr (TV)');
  if (clients.radarr) addConfigTools('radarr', 'Radarr (Movies)');

• src/index.ts:1335-1436 (handler)

  The handler (switch case) for 'radarr_review_setup' (line 1336) is grouped with sonarr_review_setup and lidarr_review_setup (lines 1335-1336). It resolves the service name (radarr), gathers configuration data via Promise.all (status, health, quality profiles, quality definitions, download clients, naming, media management, root folders, tags, indexers), and returns a comprehensive JSON review object.

  case "sonarr_review_setup":
  case "radarr_review_setup":
  case "lidarr_review_setup": {
    const serviceName = name.split('_')[0] as keyof typeof clients;
    const client = clients[serviceName];
    if (!client) throw new Error(`${serviceName} not configured`);
  
    // Gather all configuration data
    const [status, health, qualityProfiles, qualityDefinitions, downloadClients, naming, mediaManagement, rootFolders, tags, indexers] = await Promise.all([
      client.getStatus(),
      client.getHealth(),
      client.getQualityProfiles(),
      client.getQualityDefinitions(),
      client.getDownloadClients(),
      client.getNamingConfig(),
      client.getMediaManagement(),
      client.getRootFoldersDetailed(),
      client.getTags(),
      client.getIndexers(),
    ]);
  
    // For Lidarr, also get metadata profiles
    let metadataProfiles = null;
    if (serviceName === 'lidarr' && clients.lidarr) {
      metadataProfiles = await clients.lidarr.getMetadataProfiles();
    }
  
    const review = {
      service: serviceName,
      version: status.version,
      appName: status.appName,
      platform: {
        os: status.osName,
        isDocker: status.isDocker,
      },
      health: {
        issueCount: health.length,
        issues: health,
      },
      storage: {
        rootFolders: rootFolders.map(f => ({
          path: f.path,
          accessible: f.accessible,
          freeSpace: formatBytes(f.freeSpace),
          freeSpaceBytes: f.freeSpace,
          unmappedFolderCount: f.unmappedFolders?.length || 0,
        })),
      },
      qualityProfiles: qualityProfiles.map(p => ({
        id: p.id,
        name: p.name,
        upgradeAllowed: p.upgradeAllowed,
        cutoff: p.cutoff,
        allowedQualities: p.items
          .filter(i => i.allowed)
          .map(i => i.quality?.name || i.name || (i.items?.map(q => q.quality.name).join(', ')))
          .filter(Boolean),
        customFormatsWithScores: p.formatItems?.filter(f => f.score !== 0).length || 0,
        minFormatScore: p.minFormatScore,
      })),
      qualityDefinitions: qualityDefinitions.map(d => ({
        quality: d.quality.name,
        minSize: d.minSize + ' MB/min',
        maxSize: d.maxSize === 0 ? 'unlimited' : d.maxSize + ' MB/min',
        preferredSize: d.preferredSize + ' MB/min',
      })),
      downloadClients: downloadClients.map(c => ({
        name: c.name,
        type: c.implementationName,
        protocol: c.protocol,
        enabled: c.enable,
        priority: c.priority,
      })),
      indexers: indexers.map(i => ({
        name: i.name,
        protocol: i.protocol,
        enableRss: i.enableRss,
        enableAutomaticSearch: i.enableAutomaticSearch,
        enableInteractiveSearch: i.enableInteractiveSearch,
        priority: i.priority,
      })),
      naming: naming,
      mediaManagement: {
        recycleBin: mediaManagement.recycleBin || 'not set',
        recycleBinCleanupDays: mediaManagement.recycleBinCleanupDays,
        downloadPropersAndRepacks: mediaManagement.downloadPropersAndRepacks,
        deleteEmptyFolders: mediaManagement.deleteEmptyFolders,
        copyUsingHardlinks: mediaManagement.copyUsingHardlinks,
        importExtraFiles: mediaManagement.importExtraFiles,
        extraFileExtensions: mediaManagement.extraFileExtensions,
      },
      tags: tags.map(t => t.label),
      ...(metadataProfiles && { metadataProfiles }),
    };
  
    return {
      content: [{
        type: "text",
        text: JSON.stringify(review, null, 2),
      }],
    };
  }

• src/arr-client.ts:472-530 (helper)

  The handler calls several ArrClient methods that are helpers: getQualityProfiles() (line 472), getQualityDefinitions() (line 479), getDownloadClients() (line 486), getNamingConfig() (line 493), getMediaManagement() (line 500), getHealth() (line 507), getTags() (line 514), getRootFoldersDetailed() (line 521), and getIndexers() (line 528). These methods make the actual API calls to the Radarr service.

  async getQualityProfiles(): Promise<QualityProfile[]> {
    return this.request<QualityProfile[]>('/qualityprofile');
  }
  
  /**
   * Get quality definitions (size limits)
   */
  async getQualityDefinitions(): Promise<QualityDefinition[]> {
    return this.request<QualityDefinition[]>('/qualitydefinition');
  }
  
  /**
   * Get download clients
   */
  async getDownloadClients(): Promise<DownloadClient[]> {
    return this.request<DownloadClient[]>('/downloadclient');
  }
  
  /**
   * Get naming configuration
   */
  async getNamingConfig(): Promise<NamingConfig> {
    return this.request<NamingConfig>('/config/naming');
  }
  
  /**
   * Get media management configuration
   */
  async getMediaManagement(): Promise<MediaManagementConfig> {
    return this.request<MediaManagementConfig>('/config/mediamanagement');
  }
  
  /**
   * Get health check issues
   */
  async getHealth(): Promise<HealthCheck[]> {
    return this.request<HealthCheck[]>('/health');
  }
  
  /**
   * Get all tags
   */
  async getTags(): Promise<Tag[]> {
    return this.request<Tag[]>('/tag');
  }
  
  /**
   * Get detailed root folders
   */
  async getRootFoldersDetailed(): Promise<RootFolder[]> {
    return this.request<RootFolder[]>('/rootfolder');
  }
  
  /**
   * Get indexers (per-app configuration, not Prowlarr)
   */
  async getIndexers(): Promise<Indexer[]> {
    return this.request<Indexer[]>('/indexer');
  }