@thelord/mcp-arr 1.0.0 → 1.2.0

package/dist/index.js

@@ -20,13 +20,17 @@ import { trashClient } from "./trash-client.js";
 import { LingarrClient } from "./lingarr-client.js";
 import { getLingarrTools } from "./lingarr-tools.js";
 import { handleLingarrTool, getLingarrStatus } from "./lingarr-handlers.js";
+import { BazarrClient } from "./bazarr-client.js";
+import { bazarrTools } from "./bazarr-tools.js";
+import { handleBazarrTool } from "./bazarr-handlers.js";
 const services = [
     { name: 'sonarr', displayName: 'Sonarr (TV)', url: process.env.SONARR_URL, apiKey: process.env.SONARR_API_KEY },
     { name: 'radarr', displayName: 'Radarr (Movies)', url: process.env.RADARR_URL, apiKey: process.env.RADARR_API_KEY },
     { name: 'lidarr', displayName: 'Lidarr (Music)', url: process.env.LIDARR_URL, apiKey: process.env.LIDARR_API_KEY },
     { name: 'readarr', displayName: 'Readarr (Books)', url: process.env.READARR_URL, apiKey: process.env.READARR_API_KEY },
     { name: 'prowlarr', displayName: 'Prowlarr (Indexers)', url: process.env.PROWLARR_URL, apiKey: process.env.PROWLARR_API_KEY },
-    { name: 'lingarr', displayName: 'Lingarr (Subtitles)', url: process.env.LINGARR_URL, apiKey: process.env.LINGARR_API_KEY },
+    { name: 'lingarr', displayName: 'Lingarr (Subtitle Translation)', url: process.env.LINGARR_URL, apiKey: process.env.LINGARR_API_KEY },
+    { name: 'bazarr', displayName: 'Bazarr (Subtitles)', url: process.env.BAZARR_URL, apiKey: process.env.BAZARR_API_KEY },
 ];
 // Check which services are configured
 const configuredServices = services.filter(s => s.url && s.apiKey);
@@ -58,6 +62,9 @@ for (const service of configuredServices) {
         case 'lingarr':
             clients.lingarr = new LingarrClient(config);
             break;
+        case 'bazarr':
+            clients.bazarr = new BazarrClient(config);
+            break;
     }
 }
 // Build tools based on configured services
@@ -232,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
@@ -509,6 +849,10 @@ if (clients.prowlarr) {
 if (clients.lingarr) {
     TOOLS.push(...getLingarrTools());
 }
+// Bazarr tools - imported from separate module
+if (clients.bazarr) {
+    TOOLS.push(...bazarrTools);
+}
 // Cross-service search tool
 TOOLS.push({
     name: "arr_search_all",
@@ -676,6 +1020,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         if (lingarrResult) {
             return lingarrResult;
         }
+        // Delegate Bazarr tools to separate handler module
+        if (name.startsWith('bazarr_') && clients.bazarr) {
+            const result = await handleBazarrTool(clients.bazarr, name, (args || {}));
+            return {
+                content: [{ type: "text", text: result }],
+            };
+        }
         switch (name) {
             case "arr_status": {
                 const statuses = {};
@@ -685,6 +1036,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             // Lingarr status handled by separate module
                             statuses[service.name] = await getLingarrStatus(clients.lingarr);
                         }
+                        else if (service.name === 'bazarr' && clients.bazarr) {
+                            // Bazarr has different status format
+                            const status = await clients.bazarr.getStatus();
+                            statuses[service.name] = {
+                                configured: true,
+                                connected: true,
+                                version: status.bazarr_version,
+                                appName: 'Bazarr',
+                                sonarrVersion: status.sonarr_version || 'Not connected',
+                                radarrVersion: status.radarr_version || 'Not connected',
+                            };
+                        }
                         else {
                             const client = clients[service.name];
                             if (client) {
@@ -1107,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.totalRecords,
+                                page,
+                                pageSize,
+                                releases: releases.records.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)