lidarr_review_setup

Instructions

Implementation Reference

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

  Registration of lidarr_review_setup tool via addConfigTools('lidarr', ...): The tool is dynamically registered as part of the configuration tools for Lidarr (line 203 calls addConfigTools('lidarr', 'Lidarr (Music)')). The tool 'lidarr_review_setup' is defined with name, description, and inputSchema.

    {
      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:1335-1436 (handler)

  Handler for lidarr_review_setup: The case 'lidarr_review_setup' (line 1337) falls through with 'sonarr_review_setup' and 'radarr_review_setup' to the same handler. It gathers all configuration data (status, health, quality profiles, quality definitions, download clients, naming, media management, root folders, tags, indexers) plus Lidarr-specific metadata profiles, and returns a comprehensive JSON review.

  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/index.ts:191-196 (schema)

  Input schema for lidarr_review_setup: The tool takes no parameters (empty object). The handler gathers all configuration automatically.

    inputSchema: {
      type: "object" as const,
      properties: {},
      required: [],
    },
  }

• src/arr-client.ts:138-156 (helper)

  Helper type definitions used by the review_setup handler: QualityProfile, QualityDefinition, DownloadClient, NamingConfig, MediaManagementConfig, RootFolder, HealthCheck, Tag, Indexer, MetadataProfile interfaces are defined in arr-client.ts and provide the data shapes returned by the API calls.

    titleSlug: string;
    genres: string[];
    tags: number[];
    added: string;
    ratings: { votes: number; value: number };
    movieFile?: {
      id: number;
      relativePath: string;
      path: string;
      size: number;
      dateAdded: string;
      quality: { quality: { id: number; name: string } };
    };
  }
  
  export interface Album {
    id: number;
    title: string;
    disambiguation: string;

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

  API client methods used by lidarr_review_setup handler: getQualityProfiles(), getQualityDefinitions(), getDownloadClients(), getNamingConfig(), getMediaManagement(), getHealth(), getTags(), getRootFoldersDetailed(), getIndexers() are all defined on ArrClient. LidarrClient extends ArrClient and adds getMetadataProfiles().

    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');
    }
  }