jschoubben
d7ceb05e53
Ported their real HTTP APIs (hal carried no client for these). jackett: an indexer proxy — tools only (list indexers, search), no events, no broker account, because it answers queries and has no timeline to observe. bazarr: subtitle tools + emits module.bazarr.subtitle.downloaded (poll history, diff). ombi: request tools + emits request.created/.approved. All pure emitters (their decisions originate here). Typecheck; manifests parse.
90 lines
3.3 KiB
TypeScript
90 lines
3.3 KiB
TypeScript
// The Jackett API client — jackett's own code, living in the module (novox/hq ADR 0044). Jackett is
|
|
// an indexer proxy: it normalises many torrent trackers behind one Torznab surface. This client
|
|
// talks its /api/v2.0 REST API, and only jackett's tools import it.
|
|
|
|
export interface JackettIndexer {
|
|
id: string;
|
|
name: string;
|
|
type: string; // "public" | "private" | "semi-public"
|
|
configured: boolean;
|
|
siteLink?: string;
|
|
lastError?: string;
|
|
}
|
|
|
|
export interface JackettResult {
|
|
title: string;
|
|
tracker: string;
|
|
category?: string;
|
|
size: number;
|
|
seeders?: number;
|
|
peers?: number;
|
|
publishDate?: string;
|
|
link?: string;
|
|
}
|
|
|
|
export class JackettClient {
|
|
readonly baseUrl: string;
|
|
|
|
constructor(
|
|
url: string,
|
|
private readonly apiKey: string,
|
|
) {
|
|
this.baseUrl = url.replace(/\/$/, "");
|
|
}
|
|
|
|
/**
|
|
* Build from the module's resolved environment. Jackett's REST API is keyed, so both the URL and
|
|
* the key must be present — without them there is nothing to talk to, so this throws and the
|
|
* module contributes no tools rather than failing half-configured.
|
|
*/
|
|
static fromEnv(env: NodeJS.ProcessEnv = process.env): JackettClient {
|
|
const url = env.MESH_JACKETT_URL;
|
|
const apiKey = env.MESH_JACKETT_API_KEY;
|
|
if (!url) throw new Error("no Jackett URL — set MESH_JACKETT_URL");
|
|
if (!apiKey) throw new Error("no Jackett API key — set MESH_JACKETT_API_KEY");
|
|
return new JackettClient(url, apiKey);
|
|
}
|
|
|
|
private async get(path: string, params: Record<string, string> = {}): Promise<any> {
|
|
const url = new URL(`${this.baseUrl}${path}`);
|
|
url.searchParams.set("apikey", this.apiKey);
|
|
for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v);
|
|
const res = await fetch(url.toString(), { headers: { Accept: "application/json" } });
|
|
if (!res.ok) throw new Error(`Jackett API ${path}: ${res.status} ${await res.text()}`);
|
|
return res.json();
|
|
}
|
|
|
|
/** The configured indexers Jackett proxies. `configured=false` also lists the ones not set up. */
|
|
async getIndexers(configuredOnly = true): Promise<JackettIndexer[]> {
|
|
const raw = await this.get("/api/v2.0/indexers", { configured: configuredOnly ? "true" : "false" });
|
|
const list = Array.isArray(raw) ? raw : [];
|
|
return list.map((i: any) => ({
|
|
id: i.id,
|
|
name: i.name,
|
|
type: i.type,
|
|
configured: i.configured ?? false,
|
|
siteLink: i.site_link,
|
|
lastError: i.last_error || undefined,
|
|
}));
|
|
}
|
|
|
|
/**
|
|
* A Torznab search across one indexer, or the "all" aggregate. Jackett returns a normalised JSON
|
|
* result set regardless of the underlying tracker, which is the whole point of the proxy.
|
|
*/
|
|
async search(query: string, indexer = "all", limit = 25): Promise<JackettResult[]> {
|
|
const raw = await this.get(`/api/v2.0/indexers/${encodeURIComponent(indexer)}/results`, { Query: query });
|
|
const results = Array.isArray(raw?.Results) ? raw.Results : [];
|
|
return results.slice(0, limit).map((r: any) => ({
|
|
title: r.Title,
|
|
tracker: r.Tracker ?? r.TrackerId ?? "unknown",
|
|
category: Array.isArray(r.CategoryDesc) ? r.CategoryDesc.join(", ") : r.CategoryDesc,
|
|
size: r.Size ?? 0,
|
|
seeders: r.Seeders,
|
|
peers: r.Peers,
|
|
publishDate: r.PublishDate,
|
|
link: r.Link ?? r.Details,
|
|
}));
|
|
}
|
|
}
|