feat: initial release of torrentclaw-mcp server

MCP (Model Context Protocol) server that wraps the TorrentClaw REST API,
enabling LLMs (Claude Desktop, Claude Code, Cursor, etc.) to search movies
and TV shows with torrent downloads and streaming availability.

## Tools (6)
- search_content: primary search with filters (title, genre, year, rating,
  quality, language, sort). Returns content metadata + torrent magnet links.
- get_popular: trending content ranked by clicks
- get_recent: most recently added content
- get_watch_providers: streaming availability by country (Netflix, Disney+, etc.)
- get_credits: director and top 10 cast members
- get_torrent_url: .torrent file download URL from info_hash

## Resources
- torrentclaw://stats: catalog statistics (content/torrent counts, sources)

## Prompts (4)
- search_movie, search_show, whats_new, where_to_watch

## LLM Usability
- Server description with workflow guidance for tool chaining
- Tool descriptions include trigger phrases, cross-tool references, and
  explicit parameter examples
- Formatted output includes info_hash for tool chaining and call-syntax
  cross-references (e.g. "use with get_watch_providers(content_id=42)")
- Popular/recent output hints to use search_content for torrents
- Error messages include status-specific recovery guidance (400, 404, 429, 5xx)
- Prompts reference tools by name for reliable LLM execution

## Security
- SSRF protection: validates TORRENTCLAW_API_URL against private IPs,
  localhost, link-local, and IPv6 loopback addresses
- Protocol whitelist: only http/https allowed
- Error body sanitization: 4xx truncated to 200 chars, 5xx bodies omitted
- Input validation: control char filter on queries, regex on country codes,
  genre character whitelist, content_id bounds

## Testing
- 85 tests across 13 test files
- Coverage: 99.5% statements, 95.2% branches, 98.1% functions, 99.5% lines
- Vitest v4 with v8 coverage provider, 80% thresholds enforced

## Stack
- TypeScript ESM, Node.js >= 18 (native fetch)
- @modelcontextprotocol/sdk v1.12, zod v3.24
- STDIO transport, runnable via npx torrentclaw-mcp
This commit is contained in:
Deivid Soto 2026-02-09 17:26:23 +01:00
commit d471c9b695
36 changed files with 6000 additions and 0 deletions

View file

@ -0,0 +1,97 @@
import { describe, it, expect, vi } from "vitest";
import { createMockServer } from "../helpers.js";
import { registerGetCredits } from "../../src/tools/get-credits.js";
import { TorrentClawClient, ApiError } from "../../src/api-client.js";
function createMockClient(overrides: Partial<TorrentClawClient> = {}) {
return {
search: vi.fn(),
getPopular: vi.fn(),
getRecent: vi.fn(),
getWatchProviders: vi.fn(),
getCredits: vi.fn(),
getStats: vi.fn(),
getTorrentDownloadUrl: vi.fn(),
...overrides,
} as unknown as TorrentClawClient;
}
describe("get_credits tool", () => {
it("returns formatted credits", async () => {
const client = createMockClient({
getCredits: vi.fn().mockResolvedValue({
contentId: 42,
director: "Christopher Nolan",
cast: [
{ name: "Leonardo DiCaprio", character: "Cobb", profileUrl: null },
],
}),
});
const { server, getToolHandler } = createMockServer();
registerGetCredits(server, client);
const handler = getToolHandler("get_credits");
const result = await handler({ content_id: 42 });
expect(result.content[0].text).toContain("Christopher Nolan");
expect(result.content[0].text).toContain("Leonardo DiCaprio");
});
it("passes content_id to client", async () => {
const getCreditsMock = vi.fn().mockResolvedValue({
contentId: 99,
director: null,
cast: [],
});
const client = createMockClient({ getCredits: getCreditsMock });
const { server, getToolHandler } = createMockServer();
registerGetCredits(server, client);
const handler = getToolHandler("get_credits");
await handler({ content_id: 99 });
expect(getCreditsMock).toHaveBeenCalledWith(99);
});
it("returns isError on ApiError", async () => {
const client = createMockClient({
getCredits: vi.fn().mockRejectedValue(new ApiError(503, "TMDB unavailable")),
});
const { server, getToolHandler } = createMockServer();
registerGetCredits(server, client);
const handler = getToolHandler("get_credits");
const result = await handler({ content_id: 1 });
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain("TorrentClaw API error (503)");
});
it("returns isError on generic error", async () => {
const client = createMockClient({
getCredits: vi.fn().mockRejectedValue(new Error("Boom")),
});
const { server, getToolHandler } = createMockServer();
registerGetCredits(server, client);
const handler = getToolHandler("get_credits");
const result = await handler({ content_id: 1 });
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain("Request failed: Boom");
});
it("handles non-Error throw", async () => {
const client = createMockClient({
getCredits: vi.fn().mockRejectedValue(undefined),
});
const { server, getToolHandler } = createMockServer();
registerGetCredits(server, client);
const handler = getToolHandler("get_credits");
const result = await handler({ content_id: 1 });
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain("Unknown error");
});
});

View file

@ -0,0 +1,108 @@
import { describe, it, expect, vi } from "vitest";
import { createMockServer } from "../helpers.js";
import { registerGetPopular } from "../../src/tools/get-popular.js";
import { TorrentClawClient, ApiError } from "../../src/api-client.js";
function createMockClient(overrides: Partial<TorrentClawClient> = {}) {
return {
search: vi.fn(),
getPopular: vi.fn(),
getRecent: vi.fn(),
getWatchProviders: vi.fn(),
getCredits: vi.fn(),
getStats: vi.fn(),
getTorrentDownloadUrl: vi.fn(),
...overrides,
} as unknown as TorrentClawClient;
}
describe("get_popular tool", () => {
it("returns formatted popular results", async () => {
const client = createMockClient({
getPopular: vi.fn().mockResolvedValue({
items: [
{
id: 1,
title: "Popular Movie",
year: 2024,
contentType: "movie",
posterUrl: null,
ratingImdb: "8.0",
ratingTmdb: "7.5",
clickCount: 200,
},
],
total: 1,
page: 1,
pageSize: 10,
}),
});
const { server, getToolHandler } = createMockServer();
registerGetPopular(server, client);
const handler = getToolHandler("get_popular");
const result = await handler({ limit: 5 });
expect(result.content[0].text).toContain("Popular Movie");
expect(result.content[0].text).toContain("200 clicks");
});
it("defaults limit to 10", async () => {
const getPopularMock = vi.fn().mockResolvedValue({
items: [],
total: 0,
page: 1,
pageSize: 10,
});
const client = createMockClient({ getPopular: getPopularMock });
const { server, getToolHandler } = createMockServer();
registerGetPopular(server, client);
const handler = getToolHandler("get_popular");
await handler({});
expect(getPopularMock).toHaveBeenCalledWith(10, undefined);
});
it("returns isError on ApiError", async () => {
const client = createMockClient({
getPopular: vi.fn().mockRejectedValue(new ApiError(500, "Server error")),
});
const { server, getToolHandler } = createMockServer();
registerGetPopular(server, client);
const handler = getToolHandler("get_popular");
const result = await handler({});
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain("TorrentClaw API error (500)");
});
it("returns isError on generic error", async () => {
const client = createMockClient({
getPopular: vi.fn().mockRejectedValue(new Error("Timeout")),
});
const { server, getToolHandler } = createMockServer();
registerGetPopular(server, client);
const handler = getToolHandler("get_popular");
const result = await handler({});
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain("Request failed: Timeout");
});
it("handles non-Error throw", async () => {
const client = createMockClient({
getPopular: vi.fn().mockRejectedValue("string error"),
});
const { server, getToolHandler } = createMockServer();
registerGetPopular(server, client);
const handler = getToolHandler("get_popular");
const result = await handler({});
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain("Unknown error");
});
});

View file

@ -0,0 +1,108 @@
import { describe, it, expect, vi } from "vitest";
import { createMockServer } from "../helpers.js";
import { registerGetRecent } from "../../src/tools/get-recent.js";
import { TorrentClawClient, ApiError } from "../../src/api-client.js";
function createMockClient(overrides: Partial<TorrentClawClient> = {}) {
return {
search: vi.fn(),
getPopular: vi.fn(),
getRecent: vi.fn(),
getWatchProviders: vi.fn(),
getCredits: vi.fn(),
getStats: vi.fn(),
getTorrentDownloadUrl: vi.fn(),
...overrides,
} as unknown as TorrentClawClient;
}
describe("get_recent tool", () => {
it("returns formatted recent results", async () => {
const client = createMockClient({
getRecent: vi.fn().mockResolvedValue({
items: [
{
id: 3,
title: "New Show",
year: 2025,
contentType: "show",
posterUrl: null,
ratingImdb: null,
ratingTmdb: "7.0",
createdAt: "2025-12-01T00:00:00Z",
},
],
total: 1,
page: 1,
pageSize: 10,
}),
});
const { server, getToolHandler } = createMockServer();
registerGetRecent(server, client);
const handler = getToolHandler("get_recent");
const result = await handler({});
expect(result.content[0].text).toContain("New Show");
expect(result.content[0].text).toContain("[show]");
});
it("defaults limit to 10", async () => {
const getRecentMock = vi.fn().mockResolvedValue({
items: [],
total: 0,
page: 1,
pageSize: 10,
});
const client = createMockClient({ getRecent: getRecentMock });
const { server, getToolHandler } = createMockServer();
registerGetRecent(server, client);
const handler = getToolHandler("get_recent");
await handler({});
expect(getRecentMock).toHaveBeenCalledWith(10, undefined);
});
it("returns isError on ApiError", async () => {
const client = createMockClient({
getRecent: vi.fn().mockRejectedValue(new ApiError(503, "Unavailable")),
});
const { server, getToolHandler } = createMockServer();
registerGetRecent(server, client);
const handler = getToolHandler("get_recent");
const result = await handler({});
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain("TorrentClaw API error (503)");
});
it("returns isError on generic error", async () => {
const client = createMockClient({
getRecent: vi.fn().mockRejectedValue(new Error("DNS failure")),
});
const { server, getToolHandler } = createMockServer();
registerGetRecent(server, client);
const handler = getToolHandler("get_recent");
const result = await handler({});
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain("DNS failure");
});
it("handles non-Error throw", async () => {
const client = createMockClient({
getRecent: vi.fn().mockRejectedValue(42),
});
const { server, getToolHandler } = createMockServer();
registerGetRecent(server, client);
const handler = getToolHandler("get_recent");
const result = await handler({});
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain("Unknown error");
});
});

View file

@ -0,0 +1,58 @@
import { describe, it, expect, vi } from "vitest";
import { createMockServer } from "../helpers.js";
import { registerGetTorrentUrl } from "../../src/tools/get-torrent-url.js";
import { TorrentClawClient } from "../../src/api-client.js";
function createMockClient(overrides: Partial<TorrentClawClient> = {}) {
return {
search: vi.fn(),
getPopular: vi.fn(),
getRecent: vi.fn(),
getWatchProviders: vi.fn(),
getCredits: vi.fn(),
getStats: vi.fn(),
getTorrentDownloadUrl: vi
.fn()
.mockImplementation(
(hash: string) =>
`https://torrentclaw.com/api/v1/torrent/${hash}`,
),
...overrides,
} as unknown as TorrentClawClient;
}
describe("get_torrent_url tool", () => {
it("returns download URL for valid info hash", async () => {
const client = createMockClient();
const { server, getToolHandler } = createMockServer();
registerGetTorrentUrl(server, client);
const handler = getToolHandler("get_torrent_url");
const hash = "aaf1e71c0a0e3b1c0f1a2b3c4d5e6f7a8b9c0d1e";
const result = await handler({ info_hash: hash });
expect(result.content[0].text).toContain("Download .torrent file:");
expect(result.content[0].text).toContain(hash);
expect(result.isError).toBeUndefined();
});
it("lowercases the info hash", async () => {
const getTorrentDownloadUrlMock = vi
.fn()
.mockReturnValue("https://torrentclaw.com/api/v1/torrent/abc");
const client = createMockClient({
getTorrentDownloadUrl: getTorrentDownloadUrlMock,
});
const { server, getToolHandler } = createMockServer();
registerGetTorrentUrl(server, client);
const handler = getToolHandler("get_torrent_url");
await handler({
info_hash: "AAF1E71C0A0E3B1C0F1A2B3C4D5E6F7A8B9C0D1E",
});
expect(getTorrentDownloadUrlMock).toHaveBeenCalledWith(
"aaf1e71c0a0e3b1c0f1a2b3c4d5e6f7a8b9c0d1e",
);
});
});

View file

@ -0,0 +1,106 @@
import { describe, it, expect, vi } from "vitest";
import { createMockServer } from "../helpers.js";
import { registerGetWatchProviders } from "../../src/tools/get-watch-providers.js";
import { TorrentClawClient, ApiError } from "../../src/api-client.js";
function createMockClient(overrides: Partial<TorrentClawClient> = {}) {
return {
search: vi.fn(),
getPopular: vi.fn(),
getRecent: vi.fn(),
getWatchProviders: vi.fn(),
getCredits: vi.fn(),
getStats: vi.fn(),
getTorrentDownloadUrl: vi.fn(),
...overrides,
} as unknown as TorrentClawClient;
}
describe("get_watch_providers tool", () => {
it("returns formatted watch providers", async () => {
const client = createMockClient({
getWatchProviders: vi.fn().mockResolvedValue({
contentId: 42,
country: "ES",
providers: {
flatrate: [
{ providerId: 8, name: "Netflix", logo: null, link: null, displayPriority: 1 },
],
rent: [],
buy: [],
free: [],
},
attribution: "JustWatch",
}),
});
const { server, getToolHandler } = createMockServer();
registerGetWatchProviders(server, client);
const handler = getToolHandler("get_watch_providers");
const result = await handler({ content_id: 42, country: "ES" });
expect(result.content[0].text).toContain("Netflix");
expect(result.content[0].text).toContain("content #42");
});
it("passes content_id and country to client", async () => {
const getWatchProvidersMock = vi.fn().mockResolvedValue({
contentId: 10,
country: "US",
providers: { flatrate: [], rent: [], buy: [], free: [] },
attribution: "JustWatch",
});
const client = createMockClient({
getWatchProviders: getWatchProvidersMock,
});
const { server, getToolHandler } = createMockServer();
registerGetWatchProviders(server, client);
const handler = getToolHandler("get_watch_providers");
await handler({ content_id: 10, country: "US" });
expect(getWatchProvidersMock).toHaveBeenCalledWith(10, "US");
});
it("returns isError on ApiError", async () => {
const client = createMockClient({
getWatchProviders: vi.fn().mockRejectedValue(new ApiError(404, "Not found")),
});
const { server, getToolHandler } = createMockServer();
registerGetWatchProviders(server, client);
const handler = getToolHandler("get_watch_providers");
const result = await handler({ content_id: 999, country: "US" });
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain("TorrentClaw API error (404)");
});
it("returns isError on generic error", async () => {
const client = createMockClient({
getWatchProviders: vi.fn().mockRejectedValue(new Error("Connection refused")),
});
const { server, getToolHandler } = createMockServer();
registerGetWatchProviders(server, client);
const handler = getToolHandler("get_watch_providers");
const result = await handler({ content_id: 1, country: "US" });
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain("Connection refused");
});
it("handles non-Error throw", async () => {
const client = createMockClient({
getWatchProviders: vi.fn().mockRejectedValue(null),
});
const { server, getToolHandler } = createMockServer();
registerGetWatchProviders(server, client);
const handler = getToolHandler("get_watch_providers");
const result = await handler({ content_id: 1, country: "US" });
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain("Unknown error");
});
});

View file

@ -0,0 +1,165 @@
import { describe, it, expect, vi } from "vitest";
import { createMockServer } from "../helpers.js";
import { registerSearchContent } from "../../src/tools/search-content.js";
import { TorrentClawClient, ApiError } from "../../src/api-client.js";
import type { SearchResponse } from "../../src/types.js";
function createMockClient(overrides: Partial<TorrentClawClient> = {}) {
return {
search: vi.fn(),
getPopular: vi.fn(),
getRecent: vi.fn(),
getWatchProviders: vi.fn(),
getCredits: vi.fn(),
getStats: vi.fn(),
getTorrentDownloadUrl: vi.fn(),
...overrides,
} as unknown as TorrentClawClient;
}
describe("search_content tool", () => {
it("returns formatted search results on success", async () => {
const mockResponse: SearchResponse = {
total: 1,
page: 1,
pageSize: 10,
results: [
{
id: 1,
imdbId: "tt1375666",
tmdbId: "27205",
contentType: "movie",
title: "Inception",
titleOriginal: null,
year: 2010,
overview: "A mind-bending thriller",
posterUrl: null,
backdropUrl: null,
genres: ["Action"],
ratingImdb: "8.8",
ratingTmdb: "8.4",
hasTorrents: true,
torrents: [],
},
],
};
const client = createMockClient({
search: vi.fn().mockResolvedValue(mockResponse),
});
const { server, getToolHandler } = createMockServer();
registerSearchContent(server, client);
const handler = getToolHandler("search_content");
const result = await handler({ query: "inception", type: "movie" });
expect(result.isError).toBeUndefined();
expect(result.content[0].text).toContain("Inception");
expect(result.content[0].text).toContain("Found 1 results");
});
it("passes all parameters to client.search", async () => {
const searchMock = vi.fn().mockResolvedValue({
total: 0,
page: 1,
pageSize: 10,
results: [],
});
const client = createMockClient({ search: searchMock });
const { server, getToolHandler } = createMockServer();
registerSearchContent(server, client);
const handler = getToolHandler("search_content");
await handler({
query: "test",
type: "show",
genre: "Drama",
year_min: 2020,
year_max: 2025,
min_rating: 7,
quality: "1080p",
language: "es",
sort: "seeders",
page: 2,
limit: 15,
country: "ES",
});
expect(searchMock).toHaveBeenCalledWith({
query: "test",
type: "show",
genre: "Drama",
year_min: 2020,
year_max: 2025,
min_rating: 7,
quality: "1080p",
language: "es",
sort: "seeders",
page: 2,
limit: 15,
country: "ES",
});
});
it("defaults limit to 10", async () => {
const searchMock = vi.fn().mockResolvedValue({
total: 0,
page: 1,
pageSize: 10,
results: [],
});
const client = createMockClient({ search: searchMock });
const { server, getToolHandler } = createMockServer();
registerSearchContent(server, client);
const handler = getToolHandler("search_content");
await handler({ query: "test" });
expect(searchMock).toHaveBeenCalledWith(
expect.objectContaining({ limit: 10 }),
);
});
it("returns isError on ApiError", async () => {
const client = createMockClient({
search: vi.fn().mockRejectedValue(new ApiError(429, "Rate limited")),
});
const { server, getToolHandler } = createMockServer();
registerSearchContent(server, client);
const handler = getToolHandler("search_content");
const result = await handler({ query: "test" });
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain("TorrentClaw API error (429)");
expect(result.content[0].text).toContain("Rate limit exceeded");
});
it("returns isError on generic error", async () => {
const client = createMockClient({
search: vi.fn().mockRejectedValue(new Error("Network timeout")),
});
const { server, getToolHandler } = createMockServer();
registerSearchContent(server, client);
const handler = getToolHandler("search_content");
const result = await handler({ query: "test" });
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain("Request failed: Network timeout");
});
it("handles non-Error throw", async () => {
const client = createMockClient({
search: vi.fn().mockRejectedValue("string error"),
});
const { server, getToolHandler } = createMockServer();
registerSearchContent(server, client);
const handler = getToolHandler("search_content");
const result = await handler({ query: "test" });
expect(result.isError).toBe(true);
expect(result.content[0].text).toContain("Unknown error");
});
});