mcp-arr-server 1.5.3 → 1.6.2

package/dist/index.js

@@ -3,34 +3,34 @@
  * MCP Server for *arr Media Management Suite
  *
  * Provides tools for managing Sonarr (TV), Radarr (Movies), Lidarr (Music),
- * Readarr (Books), and Prowlarr (Indexers) through Claude Code.
+ * and Prowlarr (Indexers) through Claude Code.
  *
  * Environment variables:
  * - SONARR_URL, SONARR_API_KEY
  * - RADARR_URL, RADARR_API_KEY
  * - LIDARR_URL, LIDARR_API_KEY
- * - READARR_URL, READARR_API_KEY
  * - PROWLARR_URL, PROWLARR_API_KEY
  */
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { SonarrClient, RadarrClient, LidarrClient, ReadarrClient, ProwlarrClient, } from "./arr-client.js";
+import { createServer } from "node:http";
+import { SonarrClient, RadarrClient, LidarrClient, ProwlarrClient, } from "./arr-client.js";
 import { trashClient } from "./trash-client.js";
+const SERVER_VERSION = "1.6.2";
+const TRANSPORT_MODE = (process.env.MCP_TRANSPORT || "stdio").toLowerCase();
+const HTTP_HOST = process.env.HOST || "127.0.0.1";
+const HTTP_PORT = Number(process.env.PORT || "3000");
+const HTTP_PATH = process.env.MCP_PATH || "/mcp";
 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 },
 ];
 // Check which services are configured
 const configuredServices = services.filter(s => s.url && s.apiKey);
-if (configuredServices.length === 0) {
-    console.error("Error: No *arr services configured. Set at least one pair of URL and API_KEY environment variables.");
-    console.error("Example: SONARR_URL and SONARR_API_KEY");
-    process.exit(1);
-}
 // Initialize clients for configured services
 const clients = {};
 for (const service of configuredServices) {
@@ -45,9 +45,6 @@ for (const service of configuredServices) {
         case 'lidarr':
             clients.lidarr = new LidarrClient(config);
             break;
-        case 'readarr':
-            clients.readarr = new ReadarrClient(config);
-            break;
         case 'prowlarr':
             clients.prowlarr = new ProwlarrClient(config);
             break;
@@ -58,13 +55,43 @@ const TOOLS = [
     // General tool available for all
     {
         name: "arr_status",
-        description: `Get status of all configured *arr services. Currently configured: ${configuredServices.map(s => s.displayName).join(', ')}`,
+        description: configuredServices.length > 0
+            ? `Get status of all configured *arr services. Currently configured: ${configuredServices.map(s => s.displayName).join(', ')}`
+            : "Get status of all supported *arr services. No local *arr services are currently configured, but TRaSH reference tools remain available.",
         inputSchema: {
             type: "object",
             properties: {},
             required: [],
         },
     },
+    {
+        name: "search",
+        description: "Search across configured *arr libraries plus TRaSH Guides reference profiles. This is the primary discovery tool for remote MCP clients such as ChatGPT.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Natural-language search query",
+                },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "fetch",
+        description: "Fetch a specific item returned by search. Accepts an opaque item id from the search tool.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: {
+                    type: "string",
+                    description: "Opaque result id returned by search",
+                },
+            },
+            required: ["id"],
+        },
+    },
 ];
 // Configuration review tools for each service
 // These are added dynamically based on configured services
@@ -135,16 +162,27 @@ if (clients.radarr)
     addConfigTools('radarr', 'Radarr (Movies)');
 if (clients.lidarr)
     addConfigTools('lidarr', 'Lidarr (Music)');
-if (clients.readarr)
-    addConfigTools('readarr', 'Readarr (Books)');
 // Sonarr tools
 if (clients.sonarr) {
     TOOLS.push({
         name: "sonarr_get_series",
-        description: "Get all TV series in Sonarr library",
+        description: "Get TV series from Sonarr library with optional pagination and title filtering. Defaults to limit=25 to avoid very large responses. Use offset to fetch additional pages.",
         inputSchema: {
             type: "object",
-            properties: {},
+            properties: {
+                limit: {
+                    type: "number",
+                    description: "Maximum number of series to return (default: 25, max: 100)",
+                },
+                offset: {
+                    type: "number",
+                    description: "Number of series to skip before returning results (default: 0)",
+                },
+                search: {
+                    type: "string",
+                    description: "Optional case-insensitive title filter",
+                },
+            },
             required: [],
         },
     }, {
@@ -162,10 +200,19 @@ if (clients.sonarr) {
         },
     }, {
         name: "sonarr_get_queue",
-        description: "Get Sonarr download queue",
+        description: "Get Sonarr download queue. Supports pagination with limit and offset.",
         inputSchema: {
             type: "object",
-            properties: {},
+            properties: {
+                limit: {
+                    type: "number",
+                    description: "Maximum number of queue items to return (default: 25, max: 100)",
+                },
+                offset: {
+                    type: "number",
+                    description: "Number of queue items to skip before returning results (default: 0)",
+                },
+            },
             required: [],
         },
     }, {
@@ -225,6 +272,19 @@ if (clients.sonarr) {
             },
             required: ["episodeIds"],
         },
+    }, {
+        name: "sonarr_refresh_series",
+        description: "Trigger a metadata refresh for a specific series in Sonarr",
+        inputSchema: {
+            type: "object",
+            properties: {
+                seriesId: {
+                    type: "number",
+                    description: "Series ID to refresh",
+                },
+            },
+            required: ["seriesId"],
+        },
     }, {
         name: "sonarr_add_series",
         description: "Add a TV series to Sonarr. Use sonarr_search first to find the tvdbId, and sonarr_get_root_folders / sonarr_get_quality_profiles to get valid values for rootFolderPath and qualityProfileId. Use sonarr_get_tags to get valid tag IDs.",
@@ -263,32 +323,29 @@ if (clients.sonarr) {
             },
             required: ["tvdbId", "title", "qualityProfileId", "rootFolderPath"],
         },
-    }, {
-        name: "sonarr_get_root_folders",
-        description: "Get available root folders for Sonarr. Use this to find valid rootFolderPath values when adding a series.",
-        inputSchema: {
-            type: "object",
-            properties: {},
-            required: [],
-        },
-    }, {
-        name: "sonarr_get_quality_profiles",
-        description: "Get available quality profiles for Sonarr. Use this to find valid qualityProfileId values when adding a series.",
-        inputSchema: {
-            type: "object",
-            properties: {},
-            required: [],
-        },
     });
 }
 // Radarr tools
 if (clients.radarr) {
     TOOLS.push({
         name: "radarr_get_movies",
-        description: "Get all movies in Radarr library",
+        description: "Get movies from Radarr library with optional pagination and title filtering. Defaults to limit=25 to avoid very large responses. Use offset to fetch additional pages.",
         inputSchema: {
             type: "object",
-            properties: {},
+            properties: {
+                limit: {
+                    type: "number",
+                    description: "Maximum number of movies to return (default: 25, max: 100)",
+                },
+                offset: {
+                    type: "number",
+                    description: "Number of movies to skip before returning results (default: 0)",
+                },
+                search: {
+                    type: "string",
+                    description: "Optional case-insensitive title filter",
+                },
+            },
             required: [],
         },
     }, {
@@ -306,10 +363,19 @@ if (clients.radarr) {
         },
     }, {
         name: "radarr_get_queue",
-        description: "Get Radarr download queue",
+        description: "Get Radarr download queue. Supports pagination with limit and offset.",
         inputSchema: {
             type: "object",
-            properties: {},
+            properties: {
+                limit: {
+                    type: "number",
+                    description: "Maximum number of queue items to return (default: 25, max: 100)",
+                },
+                offset: {
+                    type: "number",
+                    description: "Number of queue items to skip before returning results (default: 0)",
+                },
+            },
             required: [],
         },
     }, {
@@ -338,6 +404,19 @@ if (clients.radarr) {
             },
             required: ["movieId"],
         },
+    }, {
+        name: "radarr_refresh_movie",
+        description: "Trigger a metadata refresh for a specific movie in Radarr",
+        inputSchema: {
+            type: "object",
+            properties: {
+                movieId: {
+                    type: "number",
+                    description: "Movie ID to refresh",
+                },
+            },
+            required: ["movieId"],
+        },
     }, {
         name: "radarr_add_movie",
         description: "Add a movie to Radarr. Use radarr_search first to find the tmdbId, and radarr_get_root_folders / radarr_get_quality_profiles to get valid values. Use radarr_get_tags to get valid tag IDs.",
@@ -377,22 +456,6 @@ if (clients.radarr) {
             },
             required: ["tmdbId", "title", "qualityProfileId", "rootFolderPath"],
         },
-    }, {
-        name: "radarr_get_root_folders",
-        description: "Get available root folders for Radarr. Use this to find valid rootFolderPath values when adding a movie.",
-        inputSchema: {
-            type: "object",
-            properties: {},
-            required: [],
-        },
-    }, {
-        name: "radarr_get_quality_profiles",
-        description: "Get available quality profiles for Radarr. Use this to find valid qualityProfileId values when adding a movie.",
-        inputSchema: {
-            type: "object",
-            properties: {},
-            required: [],
-        },
     });
 }
 // Lidarr tools
@@ -420,10 +483,19 @@ if (clients.lidarr) {
         },
     }, {
         name: "lidarr_get_queue",
-        description: "Get Lidarr download queue",
+        description: "Get Lidarr download queue. Supports pagination with limit and offset.",
         inputSchema: {
             type: "object",
-            properties: {},
+            properties: {
+                limit: {
+                    type: "number",
+                    description: "Maximum number of queue items to return (default: 25, max: 100)",
+                },
+                offset: {
+                    type: "number",
+                    description: "Number of queue items to skip before returning results (default: 0)",
+                },
+            },
             required: [],
         },
     }, {
@@ -542,154 +614,6 @@ if (clients.lidarr) {
         },
     });
 }
-// Readarr tools
-if (clients.readarr) {
-    TOOLS.push({
-        name: "readarr_get_authors",
-        description: "Get all authors in Readarr library",
-        inputSchema: {
-            type: "object",
-            properties: {},
-            required: [],
-        },
-    }, {
-        name: "readarr_search",
-        description: "Search for authors by name. Returns results with foreignAuthorId needed for readarr_add_author.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                term: {
-                    type: "string",
-                    description: "Search term (author name)",
-                },
-            },
-            required: ["term"],
-        },
-    }, {
-        name: "readarr_get_queue",
-        description: "Get Readarr download queue",
-        inputSchema: {
-            type: "object",
-            properties: {},
-            required: [],
-        },
-    }, {
-        name: "readarr_get_books",
-        description: "Get books for an author in Readarr. Shows which books are available and which are missing.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                authorId: {
-                    type: "number",
-                    description: "Author ID to get books for",
-                },
-            },
-            required: ["authorId"],
-        },
-    }, {
-        name: "readarr_search_book",
-        description: "Trigger a search for a specific book to download",
-        inputSchema: {
-            type: "object",
-            properties: {
-                bookIds: {
-                    type: "array",
-                    items: { type: "number" },
-                    description: "Book ID(s) to search for",
-                },
-            },
-            required: ["bookIds"],
-        },
-    }, {
-        name: "readarr_search_missing",
-        description: "Trigger a search for all missing books for an author",
-        inputSchema: {
-            type: "object",
-            properties: {
-                authorId: {
-                    type: "number",
-                    description: "Author ID to search missing books for",
-                },
-            },
-            required: ["authorId"],
-        },
-    }, {
-        name: "readarr_get_calendar",
-        description: "Get upcoming book releases from Readarr",
-        inputSchema: {
-            type: "object",
-            properties: {
-                days: {
-                    type: "number",
-                    description: "Number of days to look ahead (default: 30)",
-                },
-            },
-            required: [],
-        },
-    }, {
-        name: "readarr_add_author",
-        description: "Add an author to Readarr. Use readarr_search first to find the foreignAuthorId, and readarr_get_root_folders / readarr_get_quality_profiles / readarr_get_metadata_profiles to get valid values. Use readarr_get_tags to get valid tag IDs.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                foreignAuthorId: {
-                    type: "string",
-                    description: "Foreign author ID from readarr_search results",
-                },
-                authorName: {
-                    type: "string",
-                    description: "Author name",
-                },
-                qualityProfileId: {
-                    type: "number",
-                    description: "Quality profile ID from readarr_get_quality_profiles",
-                },
-                metadataProfileId: {
-                    type: "number",
-                    description: "Metadata profile ID from readarr_get_metadata_profiles",
-                },
-                rootFolderPath: {
-                    type: "string",
-                    description: "Root folder path from readarr_get_root_folders",
-                },
-                monitored: {
-                    type: "boolean",
-                    description: "Whether to monitor the author (default: true)",
-                },
-                tags: {
-                    type: "array",
-                    items: { type: "number" },
-                    description: "Array of tag IDs from readarr_get_tags (optional)",
-                },
-            },
-            required: ["foreignAuthorId", "authorName", "qualityProfileId", "metadataProfileId", "rootFolderPath"],
-        },
-    }, {
-        name: "readarr_get_root_folders",
-        description: "Get available root folders for Readarr. Use this to find valid rootFolderPath values when adding an author.",
-        inputSchema: {
-            type: "object",
-            properties: {},
-            required: [],
-        },
-    }, {
-        name: "readarr_get_quality_profiles",
-        description: "Get available quality profiles for Readarr. Use this to find valid qualityProfileId values when adding an author.",
-        inputSchema: {
-            type: "object",
-            properties: {},
-            required: [],
-        },
-    }, {
-        name: "readarr_get_metadata_profiles",
-        description: "Get available metadata profiles for Readarr. Use this to find valid metadataProfileId values when adding an author.",
-        inputSchema: {
-            type: "object",
-            properties: {},
-            required: [],
-        },
-    });
-}
 // Prowlarr tools
 if (clients.prowlarr) {
     TOOLS.push({
@@ -879,12 +803,188 @@ TOOLS.push({
 // Create server instance
 const server = new Server({
     name: "mcp-arr",
-    version: "1.0.0",
+    version: SERVER_VERSION,
 }, {
     capabilities: {
         tools: {},
     },
 });
+function buildResourceUrl(path) {
+    return `mcp-arr://${path}`;
+}
+function jsonText(data) {
+    return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    };
+}
+function textError(message) {
+    return {
+        content: [{ type: "text", text: message }],
+        isError: true,
+    };
+}
+async function runUnifiedSearch(query) {
+    const results = [];
+    const trimmedQuery = query.trim();
+    if (trimmedQuery.length === 0) {
+        return results;
+    }
+    const lowerQuery = trimmedQuery.toLowerCase();
+    for (const service of ["radarr", "sonarr"]) {
+        const profiles = await trashClient.listProfiles(service);
+        results.push(...profiles
+            .filter((profile) => profile.name.toLowerCase().includes(lowerQuery) ||
+            profile.description?.toLowerCase().includes(lowerQuery))
+            .slice(0, 8)
+            .map((profile) => ({
+            id: `trash-profile:${service}:${profile.name}`,
+            title: `${profile.name} (${service})`,
+            url: buildResourceUrl(`trash/profile/${service}/${encodeURIComponent(profile.name)}`),
+            type: "trash_profile",
+            service,
+            summary: profile.description?.replace(/<br>/g, " "),
+        })));
+    }
+    if (clients.sonarr) {
+        const series = await clients.sonarr.searchSeries(trimmedQuery);
+        results.push(...series.slice(0, 5).map((item) => ({
+            id: `arr:sonarr:series:${item.tvdbId}`,
+            title: `${item.title}${item.year ? ` (${item.year})` : ""}`,
+            url: buildResourceUrl(`arr/sonarr/series/${item.tvdbId}`),
+            type: "series",
+            service: "sonarr",
+            summary: item.overview?.slice(0, 220),
+        })));
+    }
+    if (clients.radarr) {
+        const movies = await clients.radarr.searchMovies(trimmedQuery);
+        results.push(...movies.slice(0, 5).map((item) => ({
+            id: `arr:radarr:movie:${item.tmdbId}`,
+            title: `${item.title}${item.year ? ` (${item.year})` : ""}`,
+            url: buildResourceUrl(`arr/radarr/movie/${item.tmdbId}`),
+            type: "movie",
+            service: "radarr",
+            summary: item.overview?.slice(0, 220),
+        })));
+    }
+    if (clients.lidarr) {
+        const artists = await clients.lidarr.searchArtists(trimmedQuery);
+        results.push(...artists.slice(0, 5).map((item) => ({
+            id: `arr:lidarr:artist:${item.foreignArtistId}`,
+            title: item.artistName || item.title,
+            url: buildResourceUrl(`arr/lidarr/artist/${item.foreignArtistId}`),
+            type: "artist",
+            service: "lidarr",
+            summary: item.overview?.slice(0, 220),
+        })));
+    }
+    return results;
+}
+async function fetchSearchEntry(id) {
+    const [kind, service, subtype, rawId] = id.split(":");
+    if (kind === "trash-profile" && (service === "radarr" || service === "sonarr")) {
+        const profile = await trashClient.getProfile(service, rawId);
+        if (!profile) {
+            throw new Error(`TRaSH profile '${rawId}' not found for ${service}`);
+        }
+        return {
+            id,
+            title: `${profile.name} (${service})`,
+            url: buildResourceUrl(`trash/profile/${service}/${encodeURIComponent(profile.name)}`),
+            service,
+            type: "trash_profile",
+            data: {
+                name: profile.name,
+                description: profile.trash_description?.replace(/<br>/g, "\n"),
+                upgradeAllowed: profile.upgradeAllowed,
+                cutoff: profile.cutoff,
+                minFormatScore: profile.minFormatScore,
+                cutoffFormatScore: profile.cutoffFormatScore,
+                language: profile.language,
+                qualities: profile.items,
+                customFormats: Object.entries(profile.formatItems || {}).map(([name, trashId]) => ({
+                    name,
+                    trash_id: trashId,
+                })),
+            },
+        };
+    }
+    if (kind !== "arr") {
+        throw new Error(`Unsupported fetch id '${id}'`);
+    }
+    if (service === "sonarr" && subtype === "series" && clients.sonarr) {
+        const tvdbId = Number(rawId);
+        const matches = (await clients.sonarr.searchSeries(rawId)).filter((item) => item.tvdbId === tvdbId);
+        return {
+            id,
+            title: matches[0]?.title || rawId,
+            url: buildResourceUrl(`arr/sonarr/series/${rawId}`),
+            service,
+            type: subtype,
+            data: matches.slice(0, 10),
+        };
+    }
+    if (service === "radarr" && subtype === "movie" && clients.radarr) {
+        const tmdbId = Number(rawId);
+        const matches = (await clients.radarr.searchMovies(rawId)).filter((item) => item.tmdbId === tmdbId);
+        return {
+            id,
+            title: matches[0]?.title || rawId,
+            url: buildResourceUrl(`arr/radarr/movie/${rawId}`),
+            service,
+            type: subtype,
+            data: matches.slice(0, 10),
+        };
+    }
+    if (service === "lidarr" && subtype === "artist" && clients.lidarr) {
+        const matches = (await clients.lidarr.searchArtists(rawId)).filter((item) => item.foreignArtistId === rawId);
+        return {
+            id,
+            title: matches[0]?.artistName || matches[0]?.title || rawId,
+            url: buildResourceUrl(`arr/lidarr/artist/${rawId}`),
+            service,
+            type: subtype,
+            data: matches.slice(0, 10),
+        };
+    }
+    throw new Error(`Unsupported or unavailable fetch target '${id}'`);
+}
+async function getPaginatedQueue(client, args) {
+    const limit = Math.min(Math.max(Math.floor(args?.limit ?? 25), 1), 100);
+    const offset = Math.max(Math.floor(args?.offset ?? 0), 0);
+    const pageSize = 100;
+    const records = [];
+    let totalRecords = 0;
+    let page = 1;
+    while (true) {
+        const queuePage = await client.getQueue(page, pageSize);
+        totalRecords = queuePage.totalRecords;
+        records.push(...queuePage.records);
+        if (records.length >= totalRecords || queuePage.records.length === 0) {
+            break;
+        }
+        page += 1;
+    }
+    const items = records.slice(offset, offset + limit).map((q) => ({
+        title: q.title,
+        status: q.status,
+        progress: q.size > 0 ? ((1 - q.sizeleft / q.size) * 100).toFixed(1) + "%" : "unknown",
+        timeLeft: q.timeleft,
+        downloadClient: q.downloadClient,
+        protocol: q.protocol,
+        trackedDownloadStatus: q.trackedDownloadStatus,
+        trackedDownloadState: q.trackedDownloadState,
+    }));
+    return {
+        total: totalRecords,
+        returned: items.length,
+        offset,
+        limit,
+        hasMore: offset + items.length < totalRecords,
+        nextOffset: offset + items.length < totalRecords ? offset + items.length : null,
+        items,
+    };
+}
 // Handle list tools request
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     return { tools: TOOLS };
@@ -894,6 +994,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     try {
         switch (name) {
+            case "search": {
+                const query = args.query;
+                const results = await runUnifiedSearch(query);
+                return jsonText({ results });
+            }
+            case "fetch": {
+                const id = args.id;
+                const result = await fetchSearchEntry(id);
+                return jsonText(result);
+            }
             case "arr_status": {
                 const statuses = {};
                 for (const service of configuredServices) {
@@ -923,16 +1033,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         statuses[service.name] = { configured: false };
                     }
                 }
-                return {
-                    content: [{ type: "text", text: JSON.stringify(statuses, null, 2) }],
-                };
+                return jsonText(statuses);
             }
             // Dynamic config tool handlers
             // Quality Profiles
             case "sonarr_get_quality_profiles":
             case "radarr_get_quality_profiles":
-            case "lidarr_get_quality_profiles":
-            case "readarr_get_quality_profiles": {
+            case "lidarr_get_quality_profiles": {
                 const serviceName = name.split('_')[0];
                 const client = clients[serviceName];
                 if (!client)
@@ -966,8 +1073,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             // Health checks
             case "sonarr_get_health":
             case "radarr_get_health":
-            case "lidarr_get_health":
-            case "readarr_get_health": {
+            case "lidarr_get_health": {
                 const serviceName = name.split('_')[0];
                 const client = clients[serviceName];
                 if (!client)
@@ -992,8 +1098,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             // Root folders
             case "sonarr_get_root_folders":
             case "radarr_get_root_folders":
-            case "lidarr_get_root_folders":
-            case "readarr_get_root_folders": {
+            case "lidarr_get_root_folders": {
                 const serviceName = name.split('_')[0];
                 const client = clients[serviceName];
                 if (!client)
@@ -1019,8 +1124,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             // Download clients
             case "sonarr_get_download_clients":
             case "radarr_get_download_clients":
-            case "lidarr_get_download_clients":
-            case "readarr_get_download_clients": {
+            case "lidarr_get_download_clients": {
                 const serviceName = name.split('_')[0];
                 const client = clients[serviceName];
                 if (!client)
@@ -1049,8 +1153,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             // Naming config
             case "sonarr_get_naming":
             case "radarr_get_naming":
-            case "lidarr_get_naming":
-            case "readarr_get_naming": {
+            case "lidarr_get_naming": {
                 const serviceName = name.split('_')[0];
                 const client = clients[serviceName];
                 if (!client)
@@ -1066,8 +1169,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             // Tags
             case "sonarr_get_tags":
             case "radarr_get_tags":
-            case "lidarr_get_tags":
-            case "readarr_get_tags": {
+            case "lidarr_get_tags": {
                 const serviceName = name.split('_')[0];
                 const client = clients[serviceName];
                 if (!client)
@@ -1086,8 +1188,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             // Comprehensive setup review
             case "sonarr_review_setup":
             case "radarr_review_setup":
-            case "lidarr_review_setup":
-            case "readarr_review_setup": {
+            case "lidarr_review_setup": {
                 const serviceName = name.split('_')[0];
                 const client = clients[serviceName];
                 if (!client)
@@ -1105,14 +1206,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     client.getTags(),
                     client.getIndexers(),
                 ]);
-                // For Lidarr/Readarr, also get metadata profiles
+                // For Lidarr, also get metadata profiles
                 let metadataProfiles = null;
                 if (serviceName === 'lidarr' && clients.lidarr) {
                     metadataProfiles = await clients.lidarr.getMetadataProfiles();
                 }
-                else if (serviceName === 'readarr' && clients.readarr) {
-                    metadataProfiles = await clients.readarr.getMetadataProfiles();
-                }
                 const review = {
                     service: serviceName,
                     version: status.version,
@@ -1191,13 +1289,30 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "sonarr_get_series": {
                 if (!clients.sonarr)
                     throw new Error("Sonarr not configured");
-                const series = await clients.sonarr.getSeries();
+                const { limit = 25, offset = 0, search } = args;
+                const normalizedLimit = Math.max(1, Math.min(limit, 100));
+                const normalizedOffset = Math.max(0, offset);
+                const filter = search?.trim().toLowerCase();
+                const allSeries = await clients.sonarr.getSeries();
+                const filteredSeries = filter
+                    ? allSeries.filter(s => s.title.toLowerCase().includes(filter))
+                    : allSeries;
+                const pagedSeries = filteredSeries.slice(normalizedOffset, normalizedOffset + normalizedLimit);
                 return {
                     content: [{
                             type: "text",
                             text: JSON.stringify({
-                                count: series.length,
-                                series: series.map(s => ({
+                                total: allSeries.length,
+                                filteredCount: filteredSeries.length,
+                                returned: pagedSeries.length,
+                                offset: normalizedOffset,
+                                limit: normalizedLimit,
+                                hasMore: normalizedOffset + normalizedLimit < filteredSeries.length,
+                                nextOffset: normalizedOffset + normalizedLimit < filteredSeries.length
+                                    ? normalizedOffset + normalizedLimit
+                                    : null,
+                                search: search ?? null,
+                                series: pagedSeries.map(s => ({
                                     id: s.id,
                                     title: s.title,
                                     year: s.year,
@@ -1235,22 +1350,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "sonarr_get_queue": {
                 if (!clients.sonarr)
                     throw new Error("Sonarr not configured");
-                const queue = await clients.sonarr.getQueue();
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                totalRecords: queue.totalRecords,
-                                items: queue.records.map(q => ({
-                                    title: q.title,
-                                    status: q.status,
-                                    progress: ((1 - q.sizeleft / q.size) * 100).toFixed(1) + '%',
-                                    timeLeft: q.timeleft,
-                                    downloadClient: q.downloadClient,
-                                })),
-                            }, null, 2),
-                        }],
-                };
+                return jsonText(await getPaginatedQueue(clients.sonarr, args));
             }
             case "sonarr_get_calendar": {
                 if (!clients.sonarr)
@@ -1318,6 +1418,28 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         }],
                 };
             }
+            case "sonarr_refresh_series": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const seriesId = args.seriesId;
+                const series = await clients.sonarr.getSeriesById(seriesId);
+                const result = await clients.sonarr.refreshSeries(seriesId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Refresh triggered for series`,
+                                series: {
+                                    id: series.id,
+                                    title: series.title,
+                                    year: series.year,
+                                },
+                                commandId: result.id,
+                            }, null, 2),
+                        }],
+                };
+            }
             case "sonarr_add_series": {
                 if (!clients.sonarr)
                     throw new Error("Sonarr not configured");
@@ -1338,39 +1460,34 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         }],
                 };
             }
-            case "sonarr_get_root_folders": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const folders = await clients.sonarr.getRootFolders();
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify(folders, null, 2),
-                        }],
-                };
-            }
-            case "sonarr_get_quality_profiles": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const profiles = await clients.sonarr.getQualityProfiles();
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify(profiles.map(p => ({ id: p.id, name: p.name })), null, 2),
-                        }],
-                };
-            }
             // Radarr handlers
             case "radarr_get_movies": {
                 if (!clients.radarr)
                     throw new Error("Radarr not configured");
-                const movies = await clients.radarr.getMovies();
+                const { limit = 25, offset = 0, search } = args;
+                const normalizedLimit = Math.max(1, Math.min(limit, 100));
+                const normalizedOffset = Math.max(0, offset);
+                const filter = search?.trim().toLowerCase();
+                const allMovies = await clients.radarr.getMovies();
+                const filteredMovies = filter
+                    ? allMovies.filter(m => m.title.toLowerCase().includes(filter))
+                    : allMovies;
+                const pagedMovies = filteredMovies.slice(normalizedOffset, normalizedOffset + normalizedLimit);
                 return {
                     content: [{
                             type: "text",
                             text: JSON.stringify({
-                                count: movies.length,
-                                movies: movies.map(m => ({
+                                total: allMovies.length,
+                                filteredCount: filteredMovies.length,
+                                returned: pagedMovies.length,
+                                offset: normalizedOffset,
+                                limit: normalizedLimit,
+                                hasMore: normalizedOffset + normalizedLimit < filteredMovies.length,
+                                nextOffset: normalizedOffset + normalizedLimit < filteredMovies.length
+                                    ? normalizedOffset + normalizedLimit
+                                    : null,
+                                search: search ?? null,
+                                movies: pagedMovies.map(m => ({
                                     id: m.id,
                                     title: m.title,
                                     year: m.year,
@@ -1408,22 +1525,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "radarr_get_queue": {
                 if (!clients.radarr)
                     throw new Error("Radarr not configured");
-                const queue = await clients.radarr.getQueue();
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                totalRecords: queue.totalRecords,
-                                items: queue.records.map(q => ({
-                                    title: q.title,
-                                    status: q.status,
-                                    progress: ((1 - q.sizeleft / q.size) * 100).toFixed(1) + '%',
-                                    timeLeft: q.timeleft,
-                                    downloadClient: q.downloadClient,
-                                })),
-                            }, null, 2),
-                        }],
-                };
+                return jsonText(await getPaginatedQueue(clients.radarr, args));
             }
             case "radarr_get_calendar": {
                 if (!clients.radarr)
@@ -1452,6 +1554,28 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         }],
                 };
             }
+            case "radarr_refresh_movie": {
+                if (!clients.radarr)
+                    throw new Error("Radarr not configured");
+                const movieId = args.movieId;
+                const movie = await clients.radarr.getMovieById(movieId);
+                const result = await clients.radarr.refreshMovie(movieId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Refresh triggered for movie`,
+                                movie: {
+                                    id: movie.id,
+                                    title: movie.title,
+                                    year: movie.year,
+                                },
+                                commandId: result.id,
+                            }, null, 2),
+                        }],
+                };
+            }
             case "radarr_add_movie": {
                 if (!clients.radarr)
                     throw new Error("Radarr not configured");
@@ -1472,28 +1596,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         }],
                 };
             }
-            case "radarr_get_root_folders": {
-                if (!clients.radarr)
-                    throw new Error("Radarr not configured");
-                const folders = await clients.radarr.getRootFolders();
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify(folders, null, 2),
-                        }],
-                };
-            }
-            case "radarr_get_quality_profiles": {
-                if (!clients.radarr)
-                    throw new Error("Radarr not configured");
-                const profiles = await clients.radarr.getQualityProfiles();
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify(profiles.map(p => ({ id: p.id, name: p.name })), null, 2),
-                        }],
-                };
-            }
             // Lidarr handlers
             case "lidarr_get_artists": {
                 if (!clients.lidarr)
@@ -1543,22 +1645,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "lidarr_get_queue": {
                 if (!clients.lidarr)
                     throw new Error("Lidarr not configured");
-                const queue = await clients.lidarr.getQueue();
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                totalRecords: queue.totalRecords,
-                                items: queue.records.map(q => ({
-                                    title: q.title,
-                                    status: q.status,
-                                    progress: ((1 - q.sizeleft / q.size) * 100).toFixed(1) + '%',
-                                    timeLeft: q.timeleft,
-                                    downloadClient: q.downloadClient,
-                                })),
-                            }, null, 2),
-                        }],
-                };
+                return jsonText(await getPaginatedQueue(clients.lidarr, args));
             }
             case "lidarr_get_albums": {
                 if (!clients.lidarr)
@@ -1694,199 +1781,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         }],
                 };
             }
-            // Readarr handlers
-            case "readarr_get_authors": {
-                if (!clients.readarr)
-                    throw new Error("Readarr not configured");
-                const authors = await clients.readarr.getAuthors();
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                count: authors.length,
-                                authors: authors.map(a => ({
-                                    id: a.id,
-                                    authorName: a.authorName,
-                                    status: a.status,
-                                    books: a.statistics?.bookFileCount + '/' + a.statistics?.totalBookCount,
-                                    sizeOnDisk: formatBytes(a.statistics?.sizeOnDisk || 0),
-                                    monitored: a.monitored,
-                                })),
-                            }, null, 2),
-                        }],
-                };
-            }
-            case "readarr_search": {
-                if (!clients.readarr)
-                    throw new Error("Readarr not configured");
-                const term = args.term;
-                const results = await clients.readarr.searchAuthors(term);
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                count: results.length,
-                                results: results.slice(0, 10).map(r => ({
-                                    title: r.title,
-                                    foreignAuthorId: r.foreignAuthorId,
-                                    overview: r.overview?.substring(0, 200) + (r.overview && r.overview.length > 200 ? '...' : ''),
-                                })),
-                            }, null, 2),
-                        }],
-                };
-            }
-            case "readarr_get_queue": {
-                if (!clients.readarr)
-                    throw new Error("Readarr not configured");
-                const queue = await clients.readarr.getQueue();
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                totalRecords: queue.totalRecords,
-                                items: queue.records.map(q => ({
-                                    title: q.title,
-                                    status: q.status,
-                                    progress: ((1 - q.sizeleft / q.size) * 100).toFixed(1) + '%',
-                                    timeLeft: q.timeleft,
-                                    downloadClient: q.downloadClient,
-                                })),
-                            }, null, 2),
-                        }],
-                };
-            }
-            case "readarr_get_books": {
-                if (!clients.readarr)
-                    throw new Error("Readarr not configured");
-                const authorId = args.authorId;
-                const books = await clients.readarr.getBooks(authorId);
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                count: books.length,
-                                books: books.map(b => ({
-                                    id: b.id,
-                                    title: b.title,
-                                    releaseDate: b.releaseDate,
-                                    pageCount: b.pageCount,
-                                    monitored: b.monitored,
-                                    hasFile: b.statistics ? b.statistics.bookFileCount > 0 : false,
-                                    sizeOnDisk: formatBytes(b.statistics?.sizeOnDisk || 0),
-                                    grabbed: b.grabbed,
-                                })),
-                            }, null, 2),
-                        }],
-                };
-            }
-            case "readarr_search_book": {
-                if (!clients.readarr)
-                    throw new Error("Readarr not configured");
-                const bookIds = args.bookIds;
-                const result = await clients.readarr.searchBook(bookIds);
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                success: true,
-                                message: `Search triggered for ${bookIds.length} book(s)`,
-                                commandId: result.id,
-                            }, null, 2),
-                        }],
-                };
-            }
-            case "readarr_search_missing": {
-                if (!clients.readarr)
-                    throw new Error("Readarr not configured");
-                const authorId = args.authorId;
-                const result = await clients.readarr.searchMissingBooks(authorId);
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                success: true,
-                                message: `Search triggered for missing books`,
-                                commandId: result.id,
-                            }, null, 2),
-                        }],
-                };
-            }
-            case "readarr_get_calendar": {
-                if (!clients.readarr)
-                    throw new Error("Readarr not configured");
-                const days = args?.days || 30;
-                const start = new Date().toISOString().split('T')[0];
-                const end = new Date(Date.now() + days * 24 * 60 * 60 * 1000).toISOString().split('T')[0];
-                const calendar = await clients.readarr.getCalendar(start, end);
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                count: calendar.length,
-                                books: calendar.map(b => ({
-                                    id: b.id,
-                                    title: b.title,
-                                    authorId: b.authorId,
-                                    releaseDate: b.releaseDate,
-                                    monitored: b.monitored,
-                                })),
-                            }, null, 2),
-                        }],
-                };
-            }
-            case "readarr_add_author": {
-                if (!clients.readarr)
-                    throw new Error("Readarr not configured");
-                const { foreignAuthorId, authorName, qualityProfileId, metadataProfileId, rootFolderPath, monitored, tags } = args;
-                const added = await clients.readarr.addAuthor({
-                    foreignAuthorId, authorName, qualityProfileId, metadataProfileId, rootFolderPath, monitored, tags: tags ?? [],
-                });
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                success: true,
-                                message: `Added "${added.authorName}" to Readarr`,
-                                id: added.id,
-                                path: added.path,
-                                monitored: added.monitored,
-                            }, null, 2),
-                        }],
-                };
-            }
-            case "readarr_get_root_folders": {
-                if (!clients.readarr)
-                    throw new Error("Readarr not configured");
-                const folders = await clients.readarr.getRootFolders();
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify(folders, null, 2),
-                        }],
-                };
-            }
-            case "readarr_get_quality_profiles": {
-                if (!clients.readarr)
-                    throw new Error("Readarr not configured");
-                const profiles = await clients.readarr.getQualityProfiles();
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify(profiles.map(p => ({ id: p.id, name: p.name })), null, 2),
-                        }],
-                };
-            }
-            case "readarr_get_metadata_profiles": {
-                if (!clients.readarr)
-                    throw new Error("Readarr not configured");
-                const profiles = await clients.readarr.getMetadataProfiles();
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify(profiles.map(p => ({ id: p.id, name: p.name })), null, 2),
-                        }],
-                };
-            }
             // Prowlarr handlers
             case "prowlarr_get_indexers": {
                 if (!clients.prowlarr)
@@ -2000,15 +1894,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         results.lidarr = { error: e instanceof Error ? e.message : String(e) };
                     }
                 }
-                if (clients.readarr) {
-                    try {
-                        const readarrResults = await clients.readarr.searchAuthors(term);
-                        results.readarr = { count: readarrResults.length, results: readarrResults.slice(0, 5) };
-                    }
-                    catch (e) {
-                        results.readarr = { error: e instanceof Error ? e.message : String(e) };
-                    }
-                }
                 return {
                     content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
                 };
@@ -2339,11 +2224,56 @@ function formatBytes(bytes) {
     const i = Math.floor(Math.log(bytes) / Math.log(k));
     return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
 }
+async function startHttpServer() {
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: undefined,
+    });
+    await server.connect(transport);
+    const httpServer = createServer(async (req, res) => {
+        if (!req.url) {
+            res.statusCode = 400;
+            res.end("Missing URL");
+            return;
+        }
+        const requestUrl = new URL(req.url, `http://${req.headers.host || `${HTTP_HOST}:${HTTP_PORT}`}`);
+        if (requestUrl.pathname === "/health" && req.method === "GET") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+                status: "ok",
+                version: SERVER_VERSION,
+                transport: "http",
+                configuredServices: configuredServices.map((service) => service.name),
+            }));
+            return;
+        }
+        if (requestUrl.pathname !== HTTP_PATH) {
+            res.statusCode = 404;
+            res.end("Not found");
+            return;
+        }
+        try {
+            await transport.handleRequest(req, res);
+        }
+        catch (error) {
+            res.statusCode = 500;
+            res.end(error instanceof Error ? error.message : String(error));
+        }
+    });
+    await new Promise((resolve, reject) => {
+        httpServer.once("error", reject);
+        httpServer.listen(HTTP_PORT, HTTP_HOST, () => resolve());
+    });
+    console.error(`*arr MCP server running over HTTP at http://${HTTP_HOST}:${HTTP_PORT}${HTTP_PATH}`);
+}
 // Start the server
 async function main() {
+    if (TRANSPORT_MODE === "http") {
+        await startHttpServer();
+        return;
+    }
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error(`*arr MCP server running - configured services: ${configuredServices.map(s => s.name).join(', ')}`);
+    console.error(`*arr MCP server running over stdio - configured services: ${configuredServices.map(s => s.name).join(', ') || 'none (TRaSH-only mode)'}`);
 }
 main().catch((error) => {
     console.error("Fatal error:", error);