mcp-arr-server 1.5.4 → 1.6.4

package/dist/index.js

@@ -13,9 +13,17 @@
  */
 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 { createServer } from "node:http";
+import { randomUUID } from "node:crypto";
 import { SonarrClient, RadarrClient, LidarrClient, ProwlarrClient, } from "./arr-client.js";
 import { trashClient } from "./trash-client.js";
+const SERVER_VERSION = "1.6.3";
+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 },
@@ -24,11 +32,6 @@ const services = [
 ];
 // 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) {
@@ -53,13 +56,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
@@ -134,10 +167,23 @@ if (clients.lidarr)
 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: [],
         },
     }, {
@@ -155,10 +201,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: [],
         },
     }, {
@@ -218,6 +273,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.",
@@ -262,10 +330,23 @@ if (clients.sonarr) {
 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: [],
         },
     }, {
@@ -283,10 +364,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: [],
         },
     }, {
@@ -315,6 +405,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.",
@@ -381,10 +484,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: [],
         },
     }, {
@@ -692,12 +804,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 };
@@ -707,6 +995,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) {
@@ -736,9 +1034,7 @@ 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
@@ -994,13 +1290,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,
@@ -1038,22 +1351,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)
@@ -1121,6 +1419,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");
@@ -1145,13 +1465,30 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             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,
@@ -1189,22 +1526,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)
@@ -1233,6 +1555,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");
@@ -1302,22 +1646,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)
@@ -1896,11 +2225,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: randomUUID,
+    });
+    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);