@thelord/mcp-arr 1.4.0 → 1.5.0

package/dist/index.js

@@ -1272,6 +1272,260 @@ if (clients.prowlarr) {
             properties: {},
             required: [],
         },
+    }, {
+        name: "prowlarr_get_indexer",
+        description: "Get a specific indexer by ID",
+        inputSchema: {
+            type: "object",
+            properties: {
+                indexerId: {
+                    type: "number",
+                    description: "Indexer ID",
+                },
+            },
+            required: ["indexerId"],
+        },
+    }, {
+        name: "prowlarr_update_indexer",
+        description: "Update an indexer (enable/disable, priority, tags)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                indexerId: {
+                    type: "number",
+                    description: "Indexer ID to update",
+                },
+                enable: {
+                    type: "boolean",
+                    description: "Enable or disable the indexer",
+                },
+                priority: {
+                    type: "number",
+                    description: "Indexer priority (1-50, lower is higher priority)",
+                },
+                tags: {
+                    type: "array",
+                    items: { type: "number" },
+                    description: "Tag IDs to apply",
+                },
+            },
+            required: ["indexerId"],
+        },
+    }, {
+        name: "prowlarr_delete_indexer",
+        description: "Delete an indexer from Prowlarr",
+        inputSchema: {
+            type: "object",
+            properties: {
+                indexerId: {
+                    type: "number",
+                    description: "Indexer ID to delete",
+                },
+            },
+            required: ["indexerId"],
+        },
+    }, {
+        name: "prowlarr_test_indexer",
+        description: "Test a specific indexer connection",
+        inputSchema: {
+            type: "object",
+            properties: {
+                indexerId: {
+                    type: "number",
+                    description: "Indexer ID to test",
+                },
+            },
+            required: ["indexerId"],
+        },
+    }, {
+        name: "prowlarr_get_applications",
+        description: "Get all applications (Sonarr, Radarr, etc. connections)",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    }, {
+        name: "prowlarr_get_application",
+        description: "Get a specific application by ID",
+        inputSchema: {
+            type: "object",
+            properties: {
+                applicationId: {
+                    type: "number",
+                    description: "Application ID",
+                },
+            },
+            required: ["applicationId"],
+        },
+    }, {
+        name: "prowlarr_update_application",
+        description: "Update an application connection",
+        inputSchema: {
+            type: "object",
+            properties: {
+                applicationId: {
+                    type: "number",
+                    description: "Application ID to update",
+                },
+                syncLevel: {
+                    type: "string",
+                    description: "Sync level: disabled, addOnly, fullSync",
+                },
+                tags: {
+                    type: "array",
+                    items: { type: "number" },
+                    description: "Tag IDs to apply",
+                },
+            },
+            required: ["applicationId"],
+        },
+    }, {
+        name: "prowlarr_delete_application",
+        description: "Delete an application from Prowlarr",
+        inputSchema: {
+            type: "object",
+            properties: {
+                applicationId: {
+                    type: "number",
+                    description: "Application ID to delete",
+                },
+            },
+            required: ["applicationId"],
+        },
+    }, {
+        name: "prowlarr_test_application",
+        description: "Test an application connection",
+        inputSchema: {
+            type: "object",
+            properties: {
+                applicationId: {
+                    type: "number",
+                    description: "Application ID to test",
+                },
+            },
+            required: ["applicationId"],
+        },
+    }, {
+        name: "prowlarr_sync_applications",
+        description: "Sync indexers to all applications (push indexer config to Sonarr/Radarr/etc.)",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    }, {
+        name: "prowlarr_get_app_profiles",
+        description: "Get app sync profiles (control which indexers sync to which apps)",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    }, {
+        name: "prowlarr_get_history",
+        description: "Get Prowlarr history (searches, grabs, failures)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                page: {
+                    type: "number",
+                    description: "Page number (default: 1)",
+                },
+                pageSize: {
+                    type: "number",
+                    description: "Items per page (default: 20)",
+                },
+                indexerId: {
+                    type: "number",
+                    description: "Filter by indexer ID",
+                },
+            },
+            required: [],
+        },
+    }, {
+        name: "prowlarr_get_tags",
+        description: "Get all tags defined in Prowlarr",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    }, {
+        name: "prowlarr_create_tag",
+        description: "Create a new tag in Prowlarr",
+        inputSchema: {
+            type: "object",
+            properties: {
+                label: {
+                    type: "string",
+                    description: "Tag label/name",
+                },
+            },
+            required: ["label"],
+        },
+    }, {
+        name: "prowlarr_update_tag",
+        description: "Update a tag label in Prowlarr",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tagId: {
+                    type: "number",
+                    description: "Tag ID to update",
+                },
+                label: {
+                    type: "string",
+                    description: "New tag label",
+                },
+            },
+            required: ["tagId", "label"],
+        },
+    }, {
+        name: "prowlarr_delete_tag",
+        description: "Delete a tag from Prowlarr",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tagId: {
+                    type: "number",
+                    description: "Tag ID to delete",
+                },
+            },
+            required: ["tagId"],
+        },
+    }, {
+        name: "prowlarr_get_indexer_schemas",
+        description: "Get available indexer schemas (templates for adding new indexers)",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    }, {
+        name: "prowlarr_get_notifications",
+        description: "Get configured notification connections",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    }, {
+        name: "prowlarr_rss_sync",
+        description: "Trigger RSS sync for all indexers",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    }, {
+        name: "prowlarr_get_download_clients",
+        description: "Get configured download clients",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
     });
 }
 // Lingarr tools - imported from separate module to reduce merge conflicts
@@ -3137,7 +3391,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "prowlarr_get_indexers": {
                 if (!clients.prowlarr)
                     throw new Error("Prowlarr not configured");
-                const indexers = await clients.prowlarr.getIndexers();
+                const indexers = await clients.prowlarr.getProwlarrIndexers();
                 return {
                     content: [{
                             type: "text",
@@ -3147,9 +3401,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                     id: i.id,
                                     name: i.name,
                                     protocol: i.protocol,
-                                    enableRss: i.enableRss,
-                                    enableAutomaticSearch: i.enableAutomaticSearch,
-                                    enableInteractiveSearch: i.enableInteractiveSearch,
+                                    enable: i.enable,
+                                    supportsRss: i.supportsRss,
+                                    supportsSearch: i.supportsSearch,
                                     priority: i.priority,
                                 })),
                             }, null, 2),
@@ -3169,7 +3423,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 if (!clients.prowlarr)
                     throw new Error("Prowlarr not configured");
                 const results = await clients.prowlarr.testAllIndexers();
-                const indexers = await clients.prowlarr.getIndexers();
+                const indexers = await clients.prowlarr.getProwlarrIndexers();
                 const indexerMap = new Map(indexers.map(i => [i.id, i.name]));
                 return {
                     content: [{
@@ -3215,6 +3469,350 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         }],
                 };
             }
+            case "prowlarr_get_indexer": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const { indexerId } = args;
+                const indexer = await clients.prowlarr.getIndexerById(indexerId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify(indexer, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_update_indexer": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const { indexerId, enable, priority, tags } = args;
+                const updates = {};
+                if (enable !== undefined)
+                    updates.enable = enable;
+                if (priority !== undefined)
+                    updates.priority = priority;
+                if (tags !== undefined)
+                    updates.tags = tags;
+                const updated = await clients.prowlarr.updateIndexer(indexerId, updates);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                indexer: {
+                                    id: updated.id,
+                                    name: updated.name,
+                                    enable: updated.enable,
+                                    priority: updated.priority,
+                                    tags: updated.tags,
+                                },
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_delete_indexer": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const { indexerId } = args;
+                await clients.prowlarr.deleteIndexer(indexerId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ success: true, message: `Indexer ${indexerId} deleted` }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_test_indexer": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const { indexerId } = args;
+                const result = await clients.prowlarr.testIndexer(indexerId);
+                const indexer = await clients.prowlarr.getIndexerById(indexerId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                id: indexerId,
+                                name: indexer.name,
+                                isValid: result.isValid,
+                                errors: result.validationFailures.map(f => f.errorMessage),
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_get_applications": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const apps = await clients.prowlarr.getApplications();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                count: apps.length,
+                                applications: apps.map(a => ({
+                                    id: a.id,
+                                    name: a.name,
+                                    implementation: a.implementation,
+                                    syncLevel: a.syncLevel,
+                                    tags: a.tags,
+                                })),
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_get_application": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const { applicationId } = args;
+                const app = await clients.prowlarr.getApplicationById(applicationId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify(app, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_update_application": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const { applicationId, syncLevel, tags } = args;
+                const updates = {};
+                if (syncLevel !== undefined)
+                    updates.syncLevel = syncLevel;
+                if (tags !== undefined)
+                    updates.tags = tags;
+                const updated = await clients.prowlarr.updateApplication(applicationId, updates);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                application: {
+                                    id: updated.id,
+                                    name: updated.name,
+                                    syncLevel: updated.syncLevel,
+                                    tags: updated.tags,
+                                },
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_delete_application": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const { applicationId } = args;
+                await clients.prowlarr.deleteApplication(applicationId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ success: true, message: `Application ${applicationId} deleted` }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_test_application": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const { applicationId } = args;
+                const result = await clients.prowlarr.testApplication(applicationId);
+                const app = await clients.prowlarr.getApplicationById(applicationId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                id: applicationId,
+                                name: app.name,
+                                isValid: result.isValid,
+                                errors: result.validationFailures.map(f => f.errorMessage),
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_sync_applications": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const result = await clients.prowlarr.syncApplications();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: "Application indexer sync triggered",
+                                commandId: result.id,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_get_app_profiles": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const profiles = await clients.prowlarr.getAppProfiles();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                count: profiles.length,
+                                profiles: profiles.map(p => ({
+                                    id: p.id,
+                                    name: p.name,
+                                    enableRss: p.enableRss,
+                                    enableAutomaticSearch: p.enableAutomaticSearch,
+                                    enableInteractiveSearch: p.enableInteractiveSearch,
+                                    minimumSeeders: p.minimumSeeders,
+                                })),
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_get_history": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const { page, pageSize, indexerId } = args;
+                let history;
+                if (indexerId) {
+                    const records = await clients.prowlarr.getIndexerHistory(indexerId);
+                    history = { records, totalRecords: records.length };
+                }
+                else {
+                    history = await clients.prowlarr.getHistory(page || 1, pageSize || 20);
+                }
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                totalRecords: history.totalRecords,
+                                records: history.records.map((r) => ({
+                                    id: r.id,
+                                    indexerId: r.indexerId,
+                                    eventType: r.eventType,
+                                    successful: r.successful,
+                                    date: r.date,
+                                    query: r.data?.query,
+                                })),
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_get_tags": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const tags = await clients.prowlarr.getTags();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ count: tags.length, tags }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_create_tag": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const { label } = args;
+                const tag = await clients.prowlarr.createTag(label);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ success: true, tag }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_update_tag": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const { tagId, label } = args;
+                const tag = await clients.prowlarr.updateTag(tagId, label);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ success: true, tag }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_delete_tag": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const { tagId } = args;
+                await clients.prowlarr.deleteTag(tagId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ success: true, message: `Tag ${tagId} deleted` }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_get_indexer_schemas": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const schemas = await clients.prowlarr.getIndexerSchemas();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                count: schemas.length,
+                                schemas: schemas.map(s => ({
+                                    implementation: s.implementation,
+                                    name: s.name,
+                                    protocol: s.protocol,
+                                    privacy: s.privacy,
+                                })),
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_get_notifications": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const notifications = await clients.prowlarr.getNotifications();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                count: notifications.length,
+                                notifications: notifications.map(n => ({
+                                    id: n.id,
+                                    name: n.name,
+                                    implementation: n.implementation,
+                                    onHealthIssue: n.onHealthIssue,
+                                    onApplicationUpdate: n.onApplicationUpdate,
+                                })),
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_rss_sync": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const result = await clients.prowlarr.rssSync();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: "RSS sync triggered for all indexers",
+                                commandId: result.id,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_get_download_clients": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const downloadClients = await clients.prowlarr.getDownloadClients();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                count: downloadClients.length,
+                                clients: downloadClients.map(c => ({
+                                    id: c.id,
+                                    name: c.name,
+                                    implementation: c.implementation,
+                                    protocol: c.protocol,
+                                    enable: c.enable,
+                                    priority: c.priority,
+                                })),
+                            }, null, 2),
+                        }],
+                };
+            }
             // Cross-service search
             case "arr_search_all": {
                 const term = args.term;