feat: source releases from Radarr/Sonarr, drop Jellyfin

[roziscoding]

What

Drops the Jellyfin integration. Jack now reads media availability directly from Radarr/Sonarr. Because a source and a destination are now the same kind of server, the connector hierarchy collapses into a single capability-based connector.

This PR also grew a few adjacent things on top of the migration: id-based torznab search, OpenTelemetry traces + logs, connector resilience, and a small CLI. See the sections below.

Config (breaking)

servers.{sources,destinations,peers} + the global indexer block are replaced by:

• servers — flat array of radarr/sonarr, each with source / destination / autoregister: { enable, priority } (source/destination default true).
• peers — separate array of other jacks (sources only).

name is now required on both. See README.md and examples/config.jsonc.

"servers": [
  { "type": "radarr", "url": "http://radarr:7878", "apiKey": "<32 hex>",
    "source": true, "destination": true, "autoregister": { "enable": true, "priority": 1 } }
],
"peers": [ { "name": "friend", "url": "https://their-jack", "apiKey": "..." } ]

New optional env vars: OTEL_EXPORTER_OTLP_ENDPOINT (+ OTEL_SERVICE_NAME) to turn on telemetry, and HTTP_TIMEOUT_MS (default 30s) for outgoing connector requests.

Architecture

• ArrServerConnector implements both roles, gated by canSource/canDestination and guarded by new @requiresSource / @requiresDestination decorators (mirroring @requireInitialization). Radarr/Sonarr subclasses hold the movie- vs series/episode-specific queries. PeerConnector (was JackServerConnector) stays source-only. The sources/ + destinations/ split is gone.
• New normalized Release type replaces Jellyfin's BaseItemDto across the peer → torznab → blackhole flow, mirroring the *arr file metadata (scene/release name, quality, size, languages, mediaInfo, imdb/tmdb/tvdb ids). The absolute file path is re-resolved on the source jack and never serialized.
• Auto-registration is now per-server (autoregister.enable + autoregister.priority) instead of the global indexer flag.

Search behaviour

Searches match how Radarr/Sonarr actually query, and avoid listing peers' whole libraries:

• By id, server-side where possible: Radarr prefers tmdbid (a targeted GET /api/v3/movie?tmdbId= lookup) then falls back to imdbid (compared with the tt prefix normalized — Radarr queries without it). Sonarr uses tvdbid (GET /api/v3/series?tvdbId=).
• No text fan-out: t=search&q=<term> returns empty (the *arr always also searches by id). A query with no term returns the catalog, which powers the RSS feed and the indexer self-test. Caps advertises only id params for movie-search/tv-search, so the *arr stops sending text queries.
• cat filtering: results are filtered by the torznab cat param (2xxx → movies, 5xxx → TV).
• Robust to older peers: the requesting jack filters a peer's response by the id it asked for, so a peer on an older version (which doesn't understand tmdbId and dumps its whole catalog) can't pollute results.

Observability

• OpenTelemetry: every request is wrapped in a server span (@hono/otel); pino logs are bridged to the OTel Logs API in-process so they carry the active span's trace/span ids (native correlation). Both are exported over OTLP/protobuf, enabled whenever an OTLP endpoint is configured. The /ping healthcheck is excluded from tracing and request logging.
• Verbose debug/trace logging across the whole search flow (fan-out, per-peer/per-source counts, outgoing HTTP, non-2xx and schema failures).
• examples/compose-with-otel.yml — jack + OpenObserve (single image, no external DB) wired together; secrets via a gitignored .env.

Resilience

• Connector init() is a retry-aware state machine: it re-pings only when never tried or the last attempt failed (logging the retry), and is a no-op while in flight or once connected.
• Searches no longer pre-filter by isInitialized — a connector that was down at boot is retried lazily and rejoins without a restart, and each connector is isolated (one failure → zero results, not a failed search).
• Every outgoing connector request is time-bounded (HTTP_TIMEOUT_MS).

CLI

scripts/cli.ts + a mise cli task to talk to a running jack: an httpie-style api command plus peer search / torznab search (id-based, --cat). Reads JACK_URL / JACK_API_KEY; colorizes JSON on a TTY (plain when piped).

Schemas

Radarr/Sonarr API types generated via @hey-api/openapi-ts (specs committed: Radarr master, Sonarr main). Connectors use ServerConnector.fetch (existing X-Api-Key auth) typed by the generated types. Jellyfin client removed.

Tests

• Unit (bun test apps packages): config, torznab (release→XML), the MSW integration suite (Radarr/Sonarr + peer releases, id search, cat filter, over-eager-peer filtering), and the connector init/retry/timeout state machine. 56 pass, tsc --noEmit clean.
• e2e: Jellyfin container dropped; setup.ts seeds Radarr with the fixture movie via its API; configs use the new servers/peers shape; tests updated to the id-based / catalog search protocol.

[roziscoding]

Migration guide — upgrading to the Radarr/Sonarr version

This release drops Jellyfin and sources media straight from Radarr/Sonarr. Migrating is a config + volumes change, plus coordinating with your peers. Follow the steps below.

1. Coordinate the upgrade with your peers

The /peer payload changed, so this is a breaking peer-protocol change (see #8): a new jack and an old jack can't talk to each other. Everyone in your peer group upgrades together — agree on a time and all bump versions, or sharing silently returns nothing.

2. Rewrite your config.jsonc

Work through these in order:

1. Flatten servers. It's now a top-level array (not an object with sources/destinations/peers). Move each Radarr/Sonarr from the old servers.destinations[] into the new servers[].
2. Add role flags to each server. source: true shares that library with peers (this is what replaces Jellyfin), destination: true registers jack there + imports grabs. Both default to true, so you can omit them unless you want one role off.
3. Move peers out. servers.peers[] → top-level peers[] (same shape).
4. Replace the indexer block with per-server autoregister: indexer.autoRegister → autoregister.enable, indexer.priority → autoregister.priority (defaults to { "enable": true, "priority": 1 }). Then delete the indexer block.
5. Drop Jellyfin. Remove the servers.sources Jellyfin entry and any JELLYFIN_API_KEY env — your shared library now comes from the Radarr/Sonarr you marked source: true.
6. Add a name to every server and peer — it's now required.

Result:

Before → After

Before

{
  "jack": { "baseUrl": "http://jack:5225", "apiKey": { "env": "JACK_API_KEY" } },
  "indexer": { "priority": 1, "autoRegister": true },
  "downloads": { "watchPath": "/data/torrents/watch", "completedPath": "/data/torrents/completed" },
  "servers": {
    "sources": [
      { "type": "jellyfin", "url": "http://jellyfin:8096", "apiKey": { "env": "JELLYFIN_API_KEY" } }
    ],
    "peers": [
      { "name": "friend", "url": "https://their-jack.example.com", "apiKey": "their-secret" }
    ],
    "destinations": [
      { "type": "radarr", "url": "http://radarr:7878", "apiKey": { "env": "RADARR_API_KEY" } },
      { "type": "sonarr", "url": "http://sonarr:8989", "apiKey": { "env": "SONARR_API_KEY" } }
    ]
  }
}

After

{
  "jack": { "baseUrl": "http://jack:5225", "apiKey": { "env": "JACK_API_KEY" } },
  "downloads": { "watchPath": "/data/torrents/watch", "completedPath": "/data/torrents/completed" },
  "servers": [
    {
      "type": "radarr",
      "url": "http://radarr:7878",
      "apiKey": { "env": "RADARR_API_KEY" },
      "name": "My Radarr",
      "source": true,        // share this library with peers (replaces Jellyfin)
      "destination": true,   // register jack here + import grabs
      "autoregister": { "enable": true, "priority": 1 }
    },
    {
      "type": "sonarr",
      "url": "http://sonarr:8989",
      "apiKey": { "env": "SONARR_API_KEY" },
      "name": "My Sonarr"
    }
  ],
  "peers": [
    { "name": "friend", "url": "https://their-jack.example.com", "apiKey": "their-secret" }
  ]
}

(Automating this rewrite is tracked in #9.)

3. Re-point your media mount

jack streams shared files straight from disk using the absolute path each Radarr/Sonarr stores for the file (movieFile.path / episodeFile.path) — the path inside the *arr container. This used to be Jellyfin's library path; it's now the *arr path, which usually differs. So in your jack docker-compose:

• Mount your media at the same path(s) your Radarr/Sonarr use, mirroring each root path:

  # jack
  volumes:
    - /srv/media/movies:/movies   # same path Radarr reports
    - /srv/media/tv:/tv           # same path Sonarr reports

• Replace the /data/media placeholder in examples/docker-compose.yml accordingly.

• If jack can't read a file at the reported path, the grab fails with a "file not found" in the blackhole watcher (same alignment rule as the blackhole watch/completed folders).

4. Restart and verify

1. docker compose up -d and watch the logs.
2. Expect Server listening, and for each destination with autoregister.enable + peers configured: Registered Jack as Torznab indexer / ... Torrent Blackhole download client.
3. Confirm sharing works: GET /peer/search?q=<title>&apikey=<jack.apiKey> should return { "items": [ ... ] } with title/size/category populated.
4. From a peer, a Torznab search (or your *arr's interactive search) should surface releases and a grab should download + import.

See the updated examples/config.jsonc and the README's Configuration + Quick start sections for the full reference.