@thelord/mcp-arr 1.1.0 → 1.2.1

package/dist/index.js

@@ -239,6 +239,339 @@ if (clients.sonarr) {
             },
             required: ["episodeIds"],
         },
+    }, {
+        name: "sonarr_add_series",
+        description: "Add a new TV series to Sonarr",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tvdbId: {
+                    type: "number",
+                    description: "TVDB ID for the series (get from sonarr_search)",
+                },
+                title: {
+                    type: "string",
+                    description: "Series title",
+                },
+                qualityProfileId: {
+                    type: "number",
+                    description: "Quality profile ID (get from sonarr_get_quality_profiles)",
+                },
+                rootFolderPath: {
+                    type: "string",
+                    description: "Root folder path (get from sonarr_get_root_folders)",
+                },
+                seasonFolder: {
+                    type: "boolean",
+                    description: "Use season folders (default: true)",
+                },
+                monitored: {
+                    type: "boolean",
+                    description: "Monitor series (default: true)",
+                },
+                tags: {
+                    type: "array",
+                    items: { type: "number" },
+                    description: "Tag IDs to apply",
+                },
+            },
+            required: ["tvdbId", "qualityProfileId", "rootFolderPath"],
+        },
+    }, {
+        name: "sonarr_update_series",
+        description: "Update an existing series configuration (monitored, tags, quality profile, path, etc.)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                seriesId: {
+                    type: "number",
+                    description: "Series ID to update",
+                },
+                monitored: {
+                    type: "boolean",
+                    description: "Monitor series",
+                },
+                qualityProfileId: {
+                    type: "number",
+                    description: "Quality profile ID",
+                },
+                tags: {
+                    type: "array",
+                    items: { type: "number" },
+                    description: "Tag IDs to apply",
+                },
+                seasonFolder: {
+                    type: "boolean",
+                    description: "Use season folders",
+                },
+                seriesType: {
+                    type: "string",
+                    description: "Series type (standard, daily, anime)",
+                },
+            },
+            required: ["seriesId"],
+        },
+    }, {
+        name: "sonarr_delete_series",
+        description: "Delete a series from Sonarr library. Optionally delete files and add to exclusion list.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                seriesId: {
+                    type: "number",
+                    description: "Series ID to delete",
+                },
+                deleteFiles: {
+                    type: "boolean",
+                    description: "Delete all files for this series (default: false)",
+                },
+                addImportListExclusion: {
+                    type: "boolean",
+                    description: "Add series to import list exclusion (default: false)",
+                },
+            },
+            required: ["seriesId"],
+        },
+    }, {
+        name: "sonarr_update_episode",
+        description: "Update episode settings (monitored status)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                episodeId: {
+                    type: "number",
+                    description: "Episode ID to update",
+                },
+                monitored: {
+                    type: "boolean",
+                    description: "Monitor episode",
+                },
+            },
+            required: ["episodeId"],
+        },
+    }, {
+        name: "sonarr_delete_episode_file",
+        description: "Delete an episode file. Useful for removing bad quality files to force re-download.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                episodeFileId: {
+                    type: "number",
+                    description: "Episode file ID to delete",
+                },
+            },
+            required: ["episodeFileId"],
+        },
+    }, {
+        name: "sonarr_refresh_series",
+        description: "Refresh series metadata from TheTVDB",
+        inputSchema: {
+            type: "object",
+            properties: {
+                seriesId: {
+                    type: "number",
+                    description: "Series ID to refresh",
+                },
+            },
+            required: ["seriesId"],
+        },
+    }, {
+        name: "sonarr_rescan_series",
+        description: "Rescan series disk for new/changed files",
+        inputSchema: {
+            type: "object",
+            properties: {
+                seriesId: {
+                    type: "number",
+                    description: "Series ID to rescan",
+                },
+            },
+            required: ["seriesId"],
+        },
+    }, {
+        name: "sonarr_rename_series",
+        description: "Rename series files according to Sonarr naming conventions",
+        inputSchema: {
+            type: "object",
+            properties: {
+                seriesId: {
+                    type: "number",
+                    description: "Series ID to rename",
+                },
+            },
+            required: ["seriesId"],
+        },
+    }, {
+        name: "sonarr_rename_episodes",
+        description: "Rename all episode files for a series",
+        inputSchema: {
+            type: "object",
+            properties: {
+                seriesId: {
+                    type: "number",
+                    description: "Series ID",
+                },
+            },
+            required: ["seriesId"],
+        },
+    }, {
+        name: "sonarr_get_releases",
+        description: "Get grabbed releases (pushes). Shows recent downloads and their status.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                seriesId: {
+                    type: "number",
+                    description: "Optional: filter to specific series ID",
+                },
+                page: {
+                    type: "number",
+                    description: "Page number (default: 1)",
+                },
+                pageSize: {
+                    type: "number",
+                    description: "Items per page (default: 10)",
+                },
+            },
+            required: [],
+        },
+    }, {
+        name: "sonarr_delete_release",
+        description: "Delete a release from history. Use sonarr_get_releases to find the GUID.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                guid: {
+                    type: "string",
+                    description: "Release GUID (from sonarr_get_releases)",
+                },
+            },
+            required: ["guid"],
+        },
+    }, {
+        name: "sonarr_create_release_profile",
+        description: "Create a release profile to control which releases are grabbed or rejected",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "Profile name",
+                },
+                enabled: {
+                    type: "boolean",
+                    description: "Enable profile (default: true)",
+                },
+                required: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Required terms (releases must contain)",
+                },
+                ignored: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Ignored terms (releases will be rejected if they contain these)",
+                },
+                tags: {
+                    type: "array",
+                    items: { type: "number" },
+                    description: "Tag IDs to apply this profile to",
+                },
+                indexerId: {
+                    type: "number",
+                    description: "Specific indexer ID to apply profile to",
+                },
+            },
+            required: ["name"],
+        },
+    }, {
+        name: "sonarr_update_release_profile",
+        description: "Update an existing release profile",
+        inputSchema: {
+            type: "object",
+            properties: {
+                profileId: {
+                    type: "number",
+                    description: "Release profile ID to update",
+                },
+                enabled: {
+                    type: "boolean",
+                    description: "Enable/disable profile",
+                },
+                required: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Required terms",
+                },
+                ignored: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Ignored terms",
+                },
+                tags: {
+                    type: "array",
+                    items: { type: "number" },
+                    description: "Tag IDs",
+                },
+            },
+            required: ["profileId"],
+        },
+    }, {
+        name: "sonarr_delete_release_profile",
+        description: "Delete a release profile",
+        inputSchema: {
+            type: "object",
+            properties: {
+                profileId: {
+                    type: "number",
+                    description: "Release profile ID to delete",
+                },
+            },
+            required: ["profileId"],
+        },
+    }, {
+        name: "sonarr_create_tag",
+        description: "Create a new tag",
+        inputSchema: {
+            type: "object",
+            properties: {
+                label: {
+                    type: "string",
+                    description: "Tag label/name",
+                },
+            },
+            required: ["label"],
+        },
+    }, {
+        name: "sonarr_update_tag",
+        description: "Update a tag label",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tagId: {
+                    type: "number",
+                    description: "Tag ID to update",
+                },
+                label: {
+                    type: "string",
+                    description: "New tag label",
+                },
+            },
+            required: ["tagId", "label"],
+        },
+    }, {
+        name: "sonarr_delete_tag",
+        description: "Delete a tag",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tagId: {
+                    type: "number",
+                    description: "Tag ID to delete",
+                },
+            },
+            required: ["tagId"],
+        },
     });
 }
 // Radarr tools
@@ -1137,6 +1470,304 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         }],
                 };
             }
+            case "sonarr_add_series": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { tvdbId, title, qualityProfileId, rootFolderPath, seasonFolder, monitored, tags } = args;
+                const series = await clients.sonarr.addSeries({
+                    tvdbId,
+                    title,
+                    qualityProfileId,
+                    rootFolderPath,
+                    seasonFolder,
+                    monitored,
+                    tags,
+                });
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Series '${title}' added to Sonarr`,
+                                seriesId: series.id,
+                                series: {
+                                    id: series.id,
+                                    title: series.title,
+                                    path: series.path,
+                                    monitored: series.monitored,
+                                },
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_update_series": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { seriesId, ...updates } = args;
+                const series = await clients.sonarr.updateSeries(seriesId, updates);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Series '${series.title}' updated`,
+                                seriesId: series.id,
+                                updates: Object.keys(updates),
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_delete_series": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { seriesId, deleteFiles = false, addImportListExclusion = false } = args;
+                await clients.sonarr.deleteSeries(seriesId, deleteFiles, addImportListExclusion);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Series deleted (files: ${deleteFiles}, exclude: ${addImportListExclusion})`,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_update_episode": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { episodeId, monitored } = args;
+                const episode = await clients.sonarr.updateEpisode(episodeId, { monitored });
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Episode ${episodeId} ${monitored ? 'monitored' : 'unmonitored'}`,
+                                episodeId: episode.id,
+                                monitored: episode.monitored,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_delete_episode_file": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { episodeFileId } = args;
+                await clients.sonarr.deleteEpisodeFile(episodeFileId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Episode file ${episodeFileId} deleted`,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_refresh_series": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { seriesId } = args;
+                const result = await clients.sonarr.refreshSeries(seriesId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Series ${seriesId} metadata refresh triggered`,
+                                commandId: result.id,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_rescan_series": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { seriesId } = args;
+                const result = await clients.sonarr.rescanSeries(seriesId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Series ${seriesId} disk rescan triggered`,
+                                commandId: result.id,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_rename_series": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { seriesId } = args;
+                const result = await clients.sonarr.renameSeries(seriesId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Series ${seriesId} files will be renamed`,
+                                commandId: result.id,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_rename_episodes": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { seriesId } = args;
+                const result = await clients.sonarr.renameEpisodes(seriesId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `All episodes for series ${seriesId} will be renamed`,
+                                commandId: result.id,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_get_releases": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { seriesId, page = 1, pageSize = 10 } = args;
+                const releases = await clients.sonarr.getReleases(seriesId, page, pageSize);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                totalRecords: releases.length,
+                                page,
+                                pageSize,
+                                releases: releases.map((r) => ({
+                                    guid: r.guid,
+                                    title: r.title,
+                                    indexer: r.indexer,
+                                    quality: r.quality,
+                                    size: formatBytes(r.size),
+                                    age: r.age,
+                                    ageHours: r.ageHours,
+                                    rejected: r.rejected,
+                                    rejectionReason: r.rejectionReason,
+                                    publishedDate: r.publishedDate,
+                                })),
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_delete_release": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { guid } = args;
+                await clients.sonarr.deleteRelease(guid);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Release ${guid} deleted from history`,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_create_release_profile": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const profile = await clients.sonarr.createReleaseProfile(args);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Release profile '${profile.name}' created`,
+                                profileId: profile.id,
+                                profile,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_update_release_profile": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { profileId, ...updates } = args;
+                const profile = await clients.sonarr.updateReleaseProfile(profileId, updates);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Release profile ${profileId} updated`,
+                                profileId: profile.id,
+                                profile,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_delete_release_profile": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { profileId } = args;
+                await clients.sonarr.deleteReleaseProfile(profileId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Release profile ${profileId} deleted`,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_create_tag": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { label } = args;
+                const tag = await clients.sonarr.createTag(label);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Tag '${label}' created`,
+                                tagId: tag.id,
+                                tag,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_update_tag": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { tagId, label } = args;
+                const tag = await clients.sonarr.updateTag(tagId, label);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Tag ${tagId} updated to '${label}'`,
+                                tagId: tag.id,
+                                tag,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_delete_tag": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { tagId } = args;
+                await clients.sonarr.deleteTag(tagId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Tag ${tagId} deleted`,
+                            }, null, 2),
+                        }],
+                };
+            }
             // Radarr handlers
             case "radarr_get_movies": {
                 if (!clients.radarr)