@musabhussainoffical/jelly 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jelly
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,68 @@
+# Jelly
+
+A dependency-free CLI streamer (very much in the spirit of **ani-cli**, but the **Jelly** way) that lets you search for any **movie, series, or anime**, pick an episode, and play the chosen source in **VLC**.
+
+It searches the free **Cinemeta** catalog (movies + series, no API key), and resolves "extracted versions" from every provider — `videasy`, `rivestream`, `vidlink`, and `anidb` — so you get all available quality/audio options regardless of whether the title is anime or live-action.
+
+## Install
+
+```bash
+npm install -g @musabhussainoffical/jelly
+```
+
+Then run VLC, or let Jelly find `vlc.exe` for you (checks common install paths, then your PATH). The command is `jelly`.
+
+> You need [VLC](https://www.videolan.org/vlc/) installed. Jelly is tested on Windows; it should also work on Linux/macOS if `vlc` is on your PATH.
+
+## Usage
+
+```bash
+jelly                    # interactive — prompts you for a search term
+jelly "attack on titan"  # search with a query right away
+jelly "stranger things" --episode 1
+jelly "your name" --dub
+```
+
+Flow (just like the Jelly desktop app):
+
+1. Search for a title — multiple words are matched, so `jelly "attack titan"` works.
+2. Pick a title from the numbered list (movies and series are shown together; anime that isn't in Cinemeta is appended).
+3. If it's a series, pick an episode.
+4. Sources are resolved from every provider and shown with quality + Sub/Dub labels.
+5. Pick a source — it plays in VLC.
+
+After a series episode finishes you get a small menu: `n` next, `r` replay, `s` change source, `q` quit.
+
+## Options
+
+| Flag | Meaning |
+| --- | --- |
+| `-q, --query <q>` | Search term (same as passing it as the first argument). |
+| `-e, --episode <n>` | Skip the episode picker and play episode `n` directly. |
+| `--dub` | Prefer the dubbed track for anime (anidb source). |
+| `-V, --version` | Print the version. |
+| `-h, --help` | Show help. |
+
+## How it works
+
+- **Catalog**: [Stremio Cinemeta](https://v3-cinemeta.strem.io) — free, official, no API key. Movies and series come from here.
+- **Providers**: `videasy` (Wings), `rivestream`, `vidlink`, and `anidb.app`. The resolver tries all of them and shows every stream it finds.
+- **Content safety**: Cinemeta results are passed through a light family-safe filter so hardcore/explicit-adult material isn't shown.
+- **Player**: VLC is launched with `--play-and-exit`, plus the Chrome user-agent and referer headers the providers need.
+
+## Publish
+
+This package is ready to publish to npm:
+
+```bash
+npm login
+npm publish
+```
+
+Published as the scoped package **`@musabhussainoffical/jelly`** (the install command is `npm i -g @musabhussainoffical/jelly`; the CLI command is `jelly`).
+
+The publish whitelist is in `package.json` (`files`: `bin`, `lib`, `README.md`, `LICENSE`) so only the needed files go out.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

package/bin/jelly.js

@@ -0,0 +1,311 @@
+#!/usr/bin/env node
+'use strict';
+// Jelly CLI — a dependency-free anime/movie/series streamer (like ani-cli, but
+// the Jelly way). It searches the free Cinemeta catalog (movies + series),
+// then resolves "extracted versions" from every provider (videasy, rivestream,
+// vidlink, anidb) and plays the chosen stream in VLC.
+
+const readline = require('readline');
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const { search: cinemetaSearch, getMeta } = require('../lib/cinemeta');
+const { search: anidbSearch } = require('../lib/anidb');
+const { resolveSources } = require('../lib/providers');
+
+const VERSION = require('../package.json').version;
+
+// ------------------------- console helpers -------------------------
+function out(s) { process.stdout.write(s + '\n'); }
+function err(s) { process.stderr.write('\x1b[1;31m' + s + '\x1b[0m\n'); }
+function info(s) { process.stdout.write('\x1b[1;34m' + s + '\x1b[0m\n'); }
+function ok(s) { process.stdout.write('\x1b[1;32m' + s + '\x1b[0m\n'); }
+
+// ------------------------- interactive input -------------------------
+function ask(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => { rl.close(); resolve(answer.trim()); });
+  });
+}
+
+async function pickNumber(items, render, prompt) {
+  items.forEach((it, i) => out(`  ${String(i + 1).padStart(2)}  ${render(it, i)}`));
+  let choice = null;
+  while (choice == null) {
+    const raw = await ask(prompt + ' ');
+    const n = parseInt(raw, 10);
+    if (!isNaN(n) && n >= 1 && n <= items.length) choice = items[n - 1];
+    else out('  Invalid selection. Pick a number from the list.');
+  }
+  return choice;
+}
+
+// ------------------------- VLC detection -------------------------
+function findVlc() {
+  const candidates = [
+    process.env.JELLY_VLC,
+    'C:\\Program Files\\VideoLAN\\VLC\\vlc.exe',
+    'C:\\Program Files (x86)\\VideoLAN\\VLC\\vlc.exe',
+    path.join(os.homedir(), 'AppData', 'Local', 'Programs', 'VideoLAN', 'VLC', 'vlc.exe'),
+  ].filter(Boolean);
+  for (const c of candidates) {
+    try { if (c && fs.existsSync(c)) return c; } catch {}
+  }
+  // PATH lookup
+  const pathEnv = (process.env.PATH || '').split(path.delimiter);
+  for (const dir of pathEnv) {
+    try {
+      const p = path.join(dir, 'vlc.exe');
+      if (fs.existsSync(p)) return p;
+    } catch {}
+  }
+  return 'vlc'; // fall back to PATH-name so spawn gives a clean error
+}
+
+function playInVlc(stream, title) {
+  const vlc = findVlc();
+  const args = [
+    '--play-and-exit',
+    '--meta-title', title,
+    '--no-video-title-show',
+  ];
+  if (stream.headers) {
+    if (stream.headers['user-agent']) { args.push('--http-user-agent', stream.headers['user-agent']); }
+    if (stream.headers.referer) { args.push('--http-referrer', stream.headers.referer); }
+  }
+  args.push(stream.url);
+  info(`Launching VLC: ${vlc}`);
+  return new Promise((resolve) => {
+    const child = spawn(vlc, args, { stdio: 'ignore', detached: false });
+    child.on('error', (e) => { err('VLC failed to start: ' + e.message); resolve({ code: -1, error: e.message }); });
+    child.on('exit', (code) => { out(`\n  VLC closed (code ${code}).\n`); resolve({ code }); });
+  });
+}
+
+// ------------------------- help / version -------------------------
+function help() {
+  out(`
+  jelly — search and stream movies/series/anime in VLC.
+
+  Usage:
+    jelly [query] [options]
+    jelly                  starts interactively, prompts for a search
+
+  Options:
+    -q, --query <q>        search term (same as passing it as the first arg)
+    -e, --episode <n>      skip the episode picker and play episode n (series)
+    --dub                  prefer the dubbed track for anime
+    -V, --version          print version
+    -h, --help             show this help
+  `);
+}
+
+function parseArgs(argv) {
+  const opts = { query: null, episode: null, dub: false };
+  const unknown = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '-h' || a === '--help') opts.help = true;
+    else if (a === '-V' || a === '--version') opts.version = true;
+    else if (a === '--dub') opts.dub = true;
+    else if (a === '-q' || a === '--query') opts.query = argv[++i] || null;
+    else if (a === '-e' || a === '--episode') opts.episode = parseInt(argv[++i], 10) || null;
+    else if (a.startsWith('-')) unknown.push(a);
+    else opts.query = (opts.query ? opts.query + ' ' : '') + a;
+  }
+  opts.unknown = unknown;
+  return opts;
+}
+
+// ------------------------- main flow -------------------------
+async function run() {
+  const argv = process.argv.slice(2);
+  const o = parseArgs(argv);
+  if (o.help) return help();
+  if (o.version) { out(VERSION); return; }
+  if (o.unknown.length) { err('Unknown option(s): ' + o.unknown.join(', ')); help(); process.exit(1); }
+
+  if (o.dub && process.platform !== 'win32') out('  Note: --dub is handled by the anidb provider on any platform.');
+
+  // 1. Get the query.
+  let query = o.query;
+  if (!query) {
+    query = await ask('\x1b[1;36mSearch for a movie, series, or anime: \x1b[0m');
+  }
+  query = query.trim();
+  if (!query) { err('No search term provided.'); process.exit(1); }
+
+  // Show both Cinemeta (movies+series) AND anidb (anime) results, merged.
+  info(`Searching "${query}"…`);
+  const [cinemetaHits, animeHits] = await Promise.allSettled([
+    cinemetaSearch(query),
+    anidbSearch(query),
+  ]);
+  const cinemetaResults = cinemetaHits.status === 'fulfilled' ? cinemetaHits.value : [];
+  const animeResults = animeHits.status === 'fulfilled' ? animeHits.value : [];
+
+  let items = cinemetaResults
+    .map((r) => sortType(r, query))
+    .filter(Boolean);
+  // Merge anidb-only results (anime not always in Cinemeta) as series candidates.
+  const anidbItems = animeResults
+    .filter((a) => !items.some((r) => r.type === 'series' && r.title.toLowerCase() === a.title.toLowerCase()))
+    .map((a) => ({ type: 'series', id: 'anidb:' + a.id, num: a.num, title: a.title, year: null, anidb: true }))
+    .sort((x, y) => titleScore(y.title, query) - titleScore(x.title, query));
+  items = items.concat(anidbItems);
+
+  if (!items.length) { err('No results found.'); process.exit(1); }
+
+  // 2. Pick a title.
+  let target;
+  if (items.length === 1) { target = items[0]; }
+  else {
+    info('Results:');
+    target = await pickNumber(
+      items,
+      (it) => `[${it.type === 'series' ? 'Series' : 'Movie'}] ${it.title}${it.year ? ' (' + it.year + ')' : ''}`,
+      'Select a title (#):'
+    );
+  }
+
+  // 3. Resolve episodes / meta.
+  let meta = null;
+  let episodes = [];
+  let tmdbId = null;
+  if (target.anidb) {
+    // Already an anidb series. Get episodes to allow picking.
+    const eps = require('../lib/anidb').episodes;
+    episodes = (await eps(target.num)).map((e) => ({ id: e.id, number: e.number, season: 1 }));
+    tmdbId = null;
+    meta = { name: target.title, type: 'series', moviedb_id: null };
+    if (!episodes.length) { err('No episodes for this anime.'); process.exit(1); }
+  } else {
+    const ttType = target.type === 'series' ? 'series' : 'movie';
+    meta = await getMeta(ttType, target.id);
+    if (!meta) { err('Could not load title details.'); process.exit(1); }
+    tmdbId = meta.moviedb_id;
+    if (target.type === 'series') {
+      episodes = meta.videos
+        .filter((v) => v.season != null && v.episode != null)
+        .sort((a, b) => a.season - b.season || a.episode - b.episode)
+        .map((v) => ({ id: v.id, number: v.episode, season: v.season, name: v.name }));
+      if (episodes.length === 1) { meta = { ...meta, actualType: 'movie' }; } // single-episode series => treat as movie
+    } else {
+      episodes = [{ id: 'movie', number: 1, season: 1, name: target.title }];
+    }
+  }
+
+  const isSeries = (meta.type === 'series' || target.type === 'series') &&
+    !(episodes.length === 1 && !target.anidb && meta.actualType === 'movie');
+
+  // 4. Pick the episode (series only).
+  let chosenEp = { season: 1, episode: o.episode > 0 ? o.episode : undefined, name: '' };
+  if (isSeries) {
+    let epOptions = episodes;
+    let epPrompt = 'Select episode (#):';
+    if (o.episode > 0) {
+      const found = episodes.find((e) => e.number === o.episode && e.season === 1);
+      if (!found) { err(`Episode ${o.episode} not found.`); process.exit(1); }
+      chosenEp = { season: 1, episode: o.episode, name: found.name || `Episode ${o.episode}` };
+    } else {
+      info(`Episodes for ${meta.name}:`);
+      chosenEp = await pickNumber(
+        epOptions,
+        (e) => `${e.season > 1 ? 'S' + e.season : ''}E${String(e.number).padStart(2, '0')}  ${e.name || ''}`.trim(),
+        epPrompt
+      );
+    }
+  } else {
+    chosenEp = { season: 1, episode: 1, name: target.title };
+  }
+
+  const epNumber = chosenEp.episode || chosenEp.number || 1;
+
+  // 5-7. Resolve → pick → play, then loop (next/replay/change source/quit).
+  let currentEp = chosenEp;
+  let currentRes = null;
+  let lastPicked = null;
+
+  async function pickAndPlay() {
+    // Resolve from ALL providers (anime and movie providers alike).
+    info(`Resolving sources for "${meta.name}${isSeries ? ' - Episode ' + currentEp.episode : ''}"… (a few seconds)`);
+    currentRes = await resolveSources({
+      tmdbId,
+      type: target.type === 'movie' && !target.anidb ? 'movie' : 'series',
+      season: currentEp.season || 1,
+      episode: currentEp.episode || 1,
+      title: meta.name,
+      year: meta.year,
+    });
+
+    if (!currentRes.ok || !currentRes.streams.length) {
+      err('No available source.');
+      out('  Providers tried: ' + currentRes.tried.map((t) => `${t.provider}${t.ok ? ' ✓' : ' ✗'}${t.error ? ' (' + t.error + ')' : ''}`).join(', '));
+      return false;
+    }
+
+    info('Available sources:');
+    const picked = await pickNumber(
+      currentRes.streams,
+      (s) => `${s.provider}  ${s.qualityLabel || 'auto'}${s.label ? '  [' + s.label + ']' : ''}`,
+      'Select a source (#):'
+    );
+    lastPicked = picked;
+    const title = `${meta.name}${isSeries ? ' - Episode ' + currentEp.episode : ''}`;
+    await playInVlc(picked, title);
+    return true;
+  }
+
+  await pickAndPlay();
+
+  // Post-play menu (ani-cli style): next / replay / change source / quit.
+  if (isSeries) {
+    const nextEp = (episodes.find((e) =>
+      (e.season || 1) === currentEp.season && e.number === (currentEp.episode || 0) + 1) ||
+      episodes.find((e) =>
+        e.season > (currentEp.season || 1) && String(e.number) === '1'));
+    while (true) {
+      const cmdStr = await ask(`\n[${meta.name} ${currentEp.season > 1 ? 'S' + currentEp.season : ''}E${currentEp.episode}] (n)ext  (r)eplay  (s)ource  (q)uit: `);
+      const cmd = (cmdStr || 'q').toLowerCase();
+      if (cmd === 'q' || cmd === 'quit') { break; }
+      if (cmd === 'n' || cmd === 'next') {
+        if (!nextEp) { out('  No next episode.'); continue; }
+        currentEp = nextEp;
+      } else if (cmd === 'r' || cmd === 'replay') {
+        if (lastPicked) { await playInVlc(lastPicked, `${meta.name} - Episode ${currentEp.episode}`); continue; }
+      } else if (cmd === 's' || cmd === 'source') {
+        // re-pick a source for the current episode
+        await pickAndPlay();
+        continue;
+      } else { out('  Unknown command.'); continue; }
+      await pickAndPlay();
+    }
+  }
+}
+
+function sortType(r, query) {
+  const t = r.name || '';
+  const score = titleScore(t, query);
+  return { ...r, title: t, _score: score };
+}
+
+function titleScore(title, query) {
+  const tl = title.toLowerCase();
+  const q = query.toLowerCase();
+  if (tl === q) return 1000;
+  if (tl.startsWith(q)) return 800;
+  if (tl.includes(q)) return 600;
+  // how many query words appear anywhere in the title
+  const words = q.split(/\s+/).filter(Boolean);
+  const hits = words.filter((w) => tl.includes(w)).length;
+  return hits * 100 + words.length - hits;
+}
+
+if (require.main === module) {
+  run().catch((e) => { err('Error: ' + (e && e.message)); process.exit(1); });
+}
+
+module.exports = { run, findVlc, titleScore };

package/lib/anidb.js

@@ -0,0 +1,126 @@
+'use strict';
+// anidb.app anime provider. Flow (same as Jelly GUI): search -> anime id ->
+// episodes -> language embed (sub=jpn / dub=eng) -> master m3u8.
+const { httpGet } = require('./http');
+
+const BASE = 'https://anidb.app';
+const UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36';
+const HEADERS = { 'user-agent': UA };
+
+function decodeEntities(s) {
+  return String(s)
+    .replace(/'/g, "'").replace(/"/g, '"')
+    .replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>');
+}
+
+// Search anidb by title keywords (spaces -> '+'). Returns [{id, num, title, poster}].
+async function search(q) {
+  const words = q.split(/\s+/).filter(Boolean);
+  if (!words.length) return [];
+  const query = words.map(encodeURIComponent).join('+');
+  const r = await httpGet(`${BASE}/browse?q=${query}`, HEADERS, 20000);
+  if (!r || r.status >= 400) {
+    if (r && /Just a moment/i.test(r.body)) throw new Error('anidb blocked by Cloudflare');
+    return [];
+  }
+  const out = [];
+  const seen = new Set();
+  const cardRe = /anime\/([a-z0-9-]+-\d+)"[^>]*title="([^"]+)"[^>]*>/g;
+  const imgRe = /src="([^"]+)"[^>]*alt="([^"]+)"/g;
+  const posters = new Map();
+  let im;
+  while ((im = imgRe.exec(r.body))) if (!posters.has(im[2])) posters.set(im[2], im[1]);
+  let m;
+  while ((m = cardRe.exec(r.body))) {
+    const id = m[1];
+    const num = Number(id.split('-').pop());
+    if (seen.has(num)) continue;
+    seen.add(num);
+    const title = decodeEntities(m[2]);
+    out.push({ id, num, title, poster: posters.get(m[2]) || null });
+  }
+  return out;
+}
+
+async function episodes(animeNum) {
+  const r = await httpGet(`${BASE}/api/frontend/anime/${animeNum}/episodes`, HEADERS, 20000);
+  if (!r || r.status >= 400) return [];
+  try {
+    const j = JSON.parse(r.body);
+    return (j.episodes || [])
+      .filter((e) => e && typeof e.number === 'number')
+      .map((e) => ({ id: e.id, number: e.number }))
+      .sort((a, b) => a.number - b.number);
+  } catch { return []; }
+}
+
+async function embedUrl(epId, lang) {
+  const r = await httpGet(`${BASE}/api/frontend/episode/${epId}/languages`, HEADERS, 20000);
+  if (!r || r.status >= 400) return null;
+  try {
+    const j = JSON.parse(r.body);
+    const src = (j.languages || []).find((l) => l.code === lang) ||
+      (j.languages || []).find((l) => l.code === 'jpn') ||
+      (j.languages || [])[0];
+    return src ? src.embed_url : null;
+  } catch { return null; }
+}
+
+async function masterFromEmbed(embedUrl) {
+  if (!embedUrl) return null;
+  const e = /^https?:\/\//.test(embedUrl) ? embedUrl : `${BASE}${embedUrl}`;
+  const r = await httpGet(e, HEADERS, 20000);
+  if (!r || r.status >= 400) return null;
+  const m = r.body.match(/file\s*:\s*'([^']+)'/);
+  return m ? m[1] : null;
+}
+
+async function resolveStream(ans, episode, mode) {
+  const eps = await episodes(ans.num);
+  if (!eps.length) return null;
+  const target = eps.find((e) => e.number === Number(episode)) || eps[0];
+  if (!target) return null;
+  const lang = mode === 'dub' ? 'eng' : 'jpn';
+  let embed = await embedUrl(target.id, lang);
+  if (!embed && mode === 'dub') embed = await embedUrl(target.id, 'jpn');
+  const master = await masterFromEmbed(embed);
+  return master;
+}
+
+// Common provider interface used by the failover engine.
+// opts: { tmdbId, type: 'movie'|'tv'|'series', season, episode, title, year }
+async function resolve({ tmdbId, type, season = 1, episode = 1, title }) {
+  if (!title) return { ok: false, error: 'no title', streams: [], subtitles: [], provider: 'anidb' };
+  let results;
+  try { results = await search(title); }
+  catch (e) { return { ok: false, error: e.message, streams: [], subtitles: [], provider: 'anidb' }; }
+  if (!results.length) return { ok: false, error: 'no anime match', streams: [], subtitles: [], provider: 'anidb' };
+
+  const lower = title.toLowerCase();
+  const chosen = results.find((r) => r.title.toLowerCase() === lower) ||
+    results.find((r) => lower.includes(r.title.toLowerCase()) || r.title.toLowerCase().includes(lower)) ||
+    results[0];
+
+  // Use season only for Series/Cinema meta; anidb episodes are a flat list,
+  // so map requested episode (season 1 -> flat episode; else best-effort).
+  const flatEp = Number(season) === 1 ? Number(episode) : Number(episode);
+
+  const [subUrl, dubUrl] = await Promise.all([
+    resolveStream(chosen, flatEp, 'sub'),
+    resolveStream(chosen, flatEp, 'dub'),
+  ]);
+
+  const streams = [];
+  if (subUrl) streams.push({ url: subUrl, qualityLabel: `Sub · E${flatEp}`, label: 'Sub', headers: { referer: BASE + '/', 'user-agent': UA } });
+  if (dubUrl) streams.push({ url: dubUrl, qualityLabel: `Dub · E${flatEp}`, label: 'Dub', headers: { referer: BASE + '/', 'user-agent': UA } });
+
+  return {
+    ok: streams.length > 0,
+    provider: 'anidb',
+    streams,
+    subtitles: [],
+    error: streams.length ? undefined : 'no source for this episode',
+  };
+}
+
+module.exports = { search, episodes, resolve, BASE, name: 'anidb' };

package/lib/cinemeta.js

@@ -0,0 +1,88 @@
+'use strict';
+// Cinemeta: Stremio's official free catalog + meta addon (no API key). Ported
+// from the Jelly GUI. Uses the pure-Node http helper.
+const { httpGet } = require('./http');
+const { filterSafe } = require('./safe-filter');
+
+const CINEMETA = 'https://v3-cinemeta.strem.io';
+const UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36';
+
+function posterOf(meta, size = 'small') {
+  return meta.poster || `https://images.metahub.space/poster/${size}/${meta.id}/img`;
+}
+function backgroundOf(meta) {
+  return meta.background || `https://images.metahub.space/background/medium/${meta.id}/img`;
+}
+
+function fromCatalogMeta(meta) {
+  return {
+    id: meta.id,
+    type: meta.type === 'series' ? 'series' : 'movie',
+    name: meta.name,
+    year: meta.year || meta.releaseInfo || undefined,
+    poster: posterOf(meta),
+    background: backgroundOf(meta),
+    genres: meta.genres || meta.genre || [],
+    description: meta.description || '',
+  };
+}
+
+async function getJson(url) {
+  const r = await httpGet(url, { 'user-agent': UA }, 20000);
+  if (!r || r.status < 200 || r.status >= 300) return null;
+  try { return JSON.parse(r.body); } catch { return null; }
+}
+
+function _doCatalog(url) {
+  return getJson(url).then((data) => {
+    if (!data || !data.metas) return [];
+    return filterSafe(data.metas.map(fromCatalogMeta));
+  });
+}
+
+// Search across movie + series catalogs. Every keyword is matched, so you can
+// search by a few words of the title ("attack titan") like the GUI.
+async function search(query) {
+  const q = encodeURIComponent(query);
+  const [movie, series] = await Promise.all([
+    _doCatalog(`${CINEMETA}/catalog/movie/top/search=${q}.json`),
+    _doCatalog(`${CINEMETA}/catalog/series/top/search=${q}.json`),
+  ]);
+  return [...movie, ...series];
+}
+
+// Full detail for a tt id. Returns meta (with moviedb_id, videos for series).
+async function getMeta(type, ttId) {
+  const data = await getJson(`${CINEMETA}/meta/${type}/${ttId}.json`);
+  if (!data || !data.meta) return null;
+  const m = data.meta;
+  return {
+    id: m.id,
+    type: m.type === 'series' ? 'series' : 'movie',
+    name: m.name,
+    year: m.year || m.releaseInfo,
+    poster: m.poster || posterOf(m),
+    background: m.background || backgroundOf(m),
+    imdbRating: m.imdbRating,
+    runtime: m.runtime,
+    description: m.description,
+    genres: m.genres || m.genre || [],
+    moviedb_id: m.moviedb_id || null,
+    videos: (m.videos || []).map((v) => ({
+      id: v.id,
+      season: v.season,
+      episode: v.episode,
+      name: v.name,
+      description: v.overview || v.description || '',
+    })),
+    raw: m,
+  };
+}
+
+module.exports = {
+  CINEMETA,
+  search,
+  getMeta,
+  posterOf,
+  backgroundOf,
+};

package/lib/crypto-videasy.js

@@ -0,0 +1,103 @@
+'use strict';
+// Videasy / Wings / SpeedRaceLight PRNG XOR cipher (pure-JS port).
+// Decrypts enc=2 "sources-with-title" responses. No WASM needed for this path.
+// CRITICAL: PRNG state must be a SPARSE Array(61) — `idx in state` is load-bearing.
+
+const MAGIC_BYTES = [109, 118, 109, 49]; // "mvm1"
+const PRNG_STATE_SIZE = 61;
+const PRNG_ROUNDS = 8;
+const GOLDEN_RATIO = 2654435769 >>> 0;
+
+function hash32(x) {
+  x >>>= 0;
+  x ^= x >>> 16;
+  x = Math.imul(x, 2246822507) >>> 0;
+  x ^= x >>> 13;
+  x = Math.imul(x, 3266489909) >>> 0;
+  x ^= x >>> 16;
+  return x >>> 0;
+}
+
+function rotl(x, n) {
+  x >>>= 0;
+  n &= 31;
+  return n === 0 ? x >>> 0 : ((x << n) | (x >>> (32 - n))) >>> 0;
+}
+
+function fnv1a(str) {
+  let h = 0x811c9dc5 >>> 0;
+  for (let i = 0; i < str.length; i++) {
+    h = Math.imul(h ^ str.charCodeAt(i), 0x01000193) >>> 0;
+  }
+  return hash32(h);
+}
+
+function initPrng(seed, mediaId) {
+  // Sparse on purpose — do NOT use Array.from({ length }) (dense undefined slots).
+  const state = new Array(PRNG_STATE_SIZE);
+  let i = hash32(fnv1a(seed) ^ hash32((mediaId >>> 0) ^ GOLDEN_RATIO)) >>> 0;
+  for (let r = 0; r < PRNG_ROUNDS; r++) {
+    const n = i % PRNG_STATE_SIZE;
+    i = rotl((i + GOLDEN_RATIO) >>> 0, 7 + (r & 7));
+    state[n] = (i ^ hash32(i)) >>> 0;
+    i = hash32((i + n) >>> 0);
+  }
+  return { state, acc: hash32(i ^ 0xa5a5a5a5) >>> 0 };
+}
+
+function nextPrngWord(ctx, counter) {
+  const s = ctx.state;
+  let a = ctx.acc;
+  const idx = a % PRNG_STATE_SIZE;
+  const inRange = +(idx in s);
+  const mask = 0 - inRange;
+  const sv = (s[idx] ?? 0) >>> 0;
+  const m = Math.imul(GOLDEN_RATIO, counter + 1) >>> 0;
+  let g = (((a ^ sv ^ m) >>> 0) | ((a & (sv ^ m) & mask) >>> 0)) >>> 0;
+  g = (rotl((g + a) >>> 0, idx & 31) ^ rotl(a, Math.imul(idx, 7) & 31)) >>> 0;
+  a = hash32((g + GOLDEN_RATIO) >>> 0);
+  s[idx] = a >>> 0;
+  ctx.acc = a;
+  return a >>> 0;
+}
+
+function generateKeyStream(seed, mediaId, length) {
+  const ctx = initPrng(seed, mediaId);
+  const out = new Uint8Array(length);
+  let idx = 0;
+  let ctr = 0;
+  while (idx < length) {
+    const w = nextPrngWord(ctx, ctr++);
+    out[idx++] = w & 0xff;
+    if (idx < length) out[idx++] = (w >>> 8) & 0xff;
+    if (idx < length) out[idx++] = (w >>> 16) & 0xff;
+    if (idx < length) out[idx++] = (w >>> 24) & 0xff;
+  }
+  return out;
+}
+
+function base64urlDecode(input) {
+  const base64 = input.replace(/-/g, '+').replace(/_/g, '/')
+    .padEnd(Math.ceil(input.length / 4) * 4, '=');
+  const binary = Buffer.from(base64, 'base64').toString('binary');
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+
+// Returns the decrypted JSON string. Throws on bad magic bytes.
+function decodeWingsdatabasePayload(ciphertext, seed, mediaId) {
+  const encrypted = base64urlDecode(ciphertext.trim());
+  const keyStream = generateKeyStream(seed, mediaId, encrypted.length);
+  for (let i = 0; i < encrypted.length; i++) {
+    encrypted[i] = (encrypted[i] ?? 0) ^ (keyStream[i] ?? 0);
+  }
+  for (let i = 0; i < MAGIC_BYTES.length; i++) {
+    if (encrypted[i] !== MAGIC_BYTES[i]) {
+      throw new Error('decrypt failed: bad seed or tampered payload');
+    }
+  }
+  return Buffer.from(encrypted.subarray(MAGIC_BYTES.length)).toString('utf8');
+}
+
+module.exports = { decodeWingsdatabasePayload };

package/lib/helpers.js

@@ -0,0 +1,21 @@
+'use strict';
+// Thin fetch helpers used by the providers, backed by pure-Node http.
+const { httpGet } = require('./http');
+
+const DEFAULT_UA =
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36';
+
+async function fetchText(url, headers = {}, timeoutMs = 20000) {
+  const r = await httpGet(url, headers, timeoutMs);
+  if (!r) throw new Error('request failed/timeout');
+  return { status: r.status, headers: {}, body: r.body };
+}
+
+async function fetchJson(url, headers = {}, timeoutMs = 20000) {
+  const r = await fetchText(url, headers, timeoutMs);
+  let data = null;
+  try { data = JSON.parse(r.body); } catch { data = null; }
+  return { ok: r.status >= 200 && r.status < 300, status: r.status, data, body: r.body };
+}
+
+module.exports = { DEFAULT_UA, fetchText, fetchJson };

package/lib/http.js

@@ -0,0 +1,24 @@
+'use strict';
+const http = require('http');
+const https = require('https');
+
+// Minimal HTTPS GET with UA + timeout. Returns {status, body} or null on error.
+function httpGet(url, headers, timeout = 20000) {
+  return new Promise((resolve) => {
+    const lib = url.startsWith('https') ? https : http;
+    const req = lib.get(url, { headers: headers || {} }, (res) => {
+      const chunks = [];
+      res.on('data', (c) => chunks.push(c));
+      res.on('end', () => {
+        resolve({ status: res.statusCode, body: Buffer.concat(chunks).toString('utf8') });
+      });
+    });
+    req.setTimeout(timeout, () => {
+      req.destroy();
+      resolve(null);
+    });
+    req.on('error', () => resolve(null));
+  });
+}
+
+module.exports = { httpGet };

package/lib/providers.js

@@ -0,0 +1,47 @@
+'use strict';
+// Unified failover engine (mirrors the Jelly GUI). Tries every provider and
+// collects all available "extracted versions": for anime AND movies, the same
+// provider set runs — videasy, rivestream, vidlink, then anidb.
+const videasy = require('./videasy');
+const rivestream = require('./rivestream');
+const vidlink = require('./vidlink');
+const anidb = require('./anidb');
+
+const DEFAULT_ORDER = ['videasy', 'rivestream', 'vidlink', 'anidb'];
+
+const PROVIDERS = { videasy, rivestream, vidlink, anidb };
+
+// opts: { tmdbId, type: 'movie'|'series'|'tv', season, episode, title, year }
+// Returns { ok, streams: [{provider, qualityLabel, label, url, headers}], tried: [] }
+async function resolveSources(opts, providerOrder = DEFAULT_ORDER) {
+  const norm = { ...opts, type: opts.type === 'series' ? 'tv' : opts.type === 'tv' ? 'tv' : 'movie' };
+  const tried = [];
+  const allStreams = [];
+  let anyOk = false;
+
+  for (const name of providerOrder) {
+    const p = PROVIDERS[name];
+    if (!p) continue;
+    let res;
+    try {
+      res = await p.resolve({ ...norm });
+    } catch (e) {
+      tried.push({ provider: name, error: e.message });
+      continue;
+    }
+    tried.push({ provider: name, ok: res.ok, error: res.error, count: (res.streams || []).length });
+    if (res.ok) anyOk = true;
+    for (const s of res.streams || []) {
+      allStreams.push({
+        provider: name,
+        qualityLabel: s.qualityLabel,
+        label: s.label,
+        url: s.url,
+        headers: s.headers,
+      });
+    }
+  }
+  return { ok: anyOk, streams: allStreams, tried };
+}
+
+module.exports = { resolveSources, PROVIDERS, DEFAULT_ORDER };

package/lib/rivestream.js

@@ -0,0 +1,133 @@
+'use strict';
+// Rivestream provider: MurmurHash secret key + backendfetch loop over services.
+const { fetchJson, DEFAULT_UA } = require('./helpers');
+
+const API = 'https://www.rivestream.app/api/backendfetch';
+
+// The obfuscation table from the rivestream bundle (66 entries).
+const cArray = [
+  '4Z7lUo','gwIVSMD','PLmz2elE2v','Z4OFV0','SZ6RZq6Zc','zhJEFYxrz8','FOm7b0',
+  'axHS3q4KDq','o9zuXQ','4Aebt','wgjjWwKKx','rY4VIxqSN','kfjbnSo','2DyrFA1M',
+  'YUixDM9B','JQvgEj0','mcuFx6JIek','eoTKe26gL','qaI9EVO1rB','0xl33btZL',
+  '1fszuAU','a7jnHzst6P','wQuJkX','cBNhTJlEOf','KNcFWhDvgT','XipDGjST',
+  'PCZJlbHoyt','2AYnMZkqd','HIpJh','KH0C3iztrG','W81hjts92','rJhAT','NON7LKoMQ',
+  'NMdY3nsKzI','t4En5v','Qq5cOQ9H','Y9nwrp','VX5FYVfsf','cE5SJG','x1vj1',
+  'HegbLe','zJ3nmt4OA','gt7rxW57dq','clIE9b','jyJ9g','B5jXjMCSx','cOzZBZTV',
+  'FTXGy','Dfh1q1','ny9jqZ2POI','X2NnMn','MBtoyD','qz4Ilys7wB','68lbOMye',
+  '3YUJnmxp','1fv5Imona','PlfvvXD7mA','ZarKfHCaPR','owORnX','dQP1YU','dVdkx',
+  'qgiK0E','cx9wQ','5F9bGa','7UjkKrp','Yvhrj','wYXez5Dg3','pG4GMU','MwMAu','rFRD5wlM',
+];
+
+const SERVICES = [
+  'apex','pulse','solstice','quasar','horizon','primevids','flowcast',
+  'asiacloud','citadel','hindicast','guru',
+];
+
+function btoa(str) {
+  return Buffer.from(str, 'binary').toString('base64');
+}
+
+// Exact port of the rivestream generateSecretKey (murmur-style hashing + cArray splice).
+function generateSecretKey(e) {
+  if (e === undefined) return 'rive';
+  try {
+    let t, n;
+    const r = String(e);
+    if (isNaN(Number(e))) {
+      const sum = r.split('').reduce((acc, char) => acc + char.charCodeAt(0), 0);
+      t = cArray[sum % cArray.length] || btoa(r);
+      n = Math.floor((sum % r.length) / 2);
+    } else {
+      const i = Number(e);
+      t = cArray[i % cArray.length] || btoa(r);
+      n = Math.floor((i % r.length) / 2);
+    }
+
+    const i = r.slice(0, n) + t + r.slice(n);
+
+    const hash2 = (s) => {
+      let t = 0;
+      for (let n = 0; n < s.length; n++) {
+        const r = s.charCodeAt(n);
+        const i = (((t = (r + (t << 6) + (t << 16) - t) >>> 0) << (n % 5)) | (t >>> (32 - (n % 5)))) >>> 0;
+        t ^= (i ^ ((r << (n % 7)) | (r >>> (8 - (n % 7))))) >>> 0;
+        t = (t + ((t >>> 11) ^ (t << 3))) >>> 0;
+      }
+      t ^= t >>> 15;
+      t = ((65535 & t) * 49842 + ((((t >>> 16) * 49842) & 65535) << 16)) >>> 0;
+      t ^= t >>> 13;
+      t = ((65535 & t) * 40503 + ((((t >>> 16) * 40503) & 65535) << 16)) >>> 0;
+      return (t ^= t >>> 16).toString(16).padStart(8, '0');
+    };
+
+    const o = (s) => {
+      let t = String(s);
+      let n = 3735928559 ^ t.length;
+      for (let e = 0; e < t.length; e++) {
+        const r = t.charCodeAt(e);
+        let rMod = r;
+        rMod ^= ((131 * e + 89) ^ (rMod << (e % 5))) & 255;
+        n = (((n << 7) | (n >>> 25)) >>> 0) ^ rMod;
+        const ii = (65535 & n) * 60205;
+        const oo = ((n >>> 16) * 60205) << 16;
+        n = (ii + oo) >>> 0;
+        n ^= n >>> 11;
+      }
+      n ^= n >>> 15;
+      n = ((65535 & n) * 49842 + (((n >>> 16) * 49842) << 16)) >>> 0;
+      n ^= n >>> 13;
+      n = ((65535 & n) * 40503 + (((n >>> 16) * 40503) << 16)) >>> 0;
+      n ^= n >>> 16;
+      n = ((65535 & n) * 10196 + (((n >>> 16) * 10196) << 16)) >>> 0;
+      return (n ^= n >>> 15).toString(16).padStart(8, '0');
+    };
+
+    return btoa(o(hash2(i)));
+  } catch {
+    return 'topSecret';
+  }
+}
+
+// Resolve with the service loop. opts: { tmdbId, type: 'movie'|'tv', season?, episode? }
+async function resolve({ tmdbId, type = 'movie', season = 1, episode = 1 }) {
+  if (!tmdbId) return { ok: false, error: 'no tmdb id' };
+
+  const requestID = type === 'movie' ? 'movieVideoProvider' : 'tvVideoProvider';
+  const secretKey = generateSecretKey(tmdbId);
+  const streams = [];
+  let lastError = null;
+
+  for (const service of SERVICES) {
+    let url = `${API}?requestID=${requestID}&id=${tmdbId}`;
+    if (type !== 'movie') url += `&season=${season}&episode=${episode}`;
+    url += `&service=${service}&secretKey=${secretKey}&proxyMode=noProxy`;
+
+    const r = await fetchJson(url, { accept: '*/*', 'user-agent': DEFAULT_UA }, 12000).catch(() => null);
+    if (!r || !r.ok) { lastError = r ? `http ${r.status}` : 'net error'; continue; }
+
+    const data = r.data;
+    // rivestream returns { data: { stream: { url, type, quality }, subtitles: [] } } or { data: null }
+    const stream = data?.data?.stream;
+    if (stream && (stream.url || stream.playlist)) {
+      const url2 = stream.url || stream.playlist;
+      streams.push({
+        url: url2,
+        qualityLabel: (stream.quality || '') + 'p' || 'auto',
+        service,
+        headers: { referer: 'https://www.rivestream.app/', 'user-agent': DEFAULT_UA },
+      });
+    } else {
+      lastError = 'no stream for this service';
+    }
+  }
+
+  return {
+    ok: streams.length > 0,
+    provider: 'Rivestream',
+    streams,
+    subtitles: [],
+    error: streams.length ? undefined : (lastError || 'no streams'),
+  };
+}
+
+module.exports = { resolve, generateSecretKey, name: 'Rivestream', SERVICES };

package/lib/safe-filter.js

@@ -0,0 +1,40 @@
+'use strict';
+// Content-safety filter. Cinemeta does not expose an MPAA certificate, so we
+// catch genuine "18+" (explicit/adult-only) content using genre + title/desc
+// blacklists that are reliable for hardcore/pornographic material. Family-safe
+// mainstream titles (even horror) are NOT blocked. (Ported from Jelly.)
+
+const ADULT_GENRES = new Set([
+  'adult', 'erotic', 'erotica', 'porn', 'pornographic', 'xxx', 'adults only',
+]);
+
+const ADULT_KEYWORDS = [
+  /\bxxx\b/i,
+  /\bhardcore\b/i,
+  /\bexplicit\s+adult\b/i,
+  /\bno\.?\s?1\s+sex\s+dating\s+fuck\b/i,
+];
+
+const ADULT_DESC = [
+  /\b(explicit sexual|graphic sex|x-rated|pornograph)/
+];
+
+function isExplicit(item) {
+  if (!item) return false;
+  const genres = (item.genres || []).map((g) => String(g).toLowerCase().trim());
+  for (const g of genres) {
+    if (ADULT_GENRES.has(g)) return true;
+  }
+  const hay = `${item.name || ''} ${item.description || ''} ${item.genres?.join(' ') || ''}`;
+  for (const re of [...ADULT_KEYWORDS, ...ADULT_DESC]) {
+    if (re.test(hay)) return true;
+  }
+  return false;
+}
+
+function filterSafe(items) {
+  if (!items) return [];
+  return items.filter((it) => !isExplicit(it));
+}
+
+module.exports = { isExplicit, filterSafe, ADULT_GENRES };

package/lib/videasy.js

@@ -0,0 +1,84 @@
+'use strict';
+// Videasy / Wings provider (default): seed -> sources-with-title(enc=2) -> PRNG XOR decrypt.
+const { fetchText, DEFAULT_UA } = require('./helpers');
+const { decodeWingsdatabasePayload } = require('./crypto-videasy');
+
+const WINGS = 'https://api.speedracelight.com';
+
+async function getSeed(tmdbId) {
+  const url = `${WINGS}/seed?mediaId=${tmdbId}`;
+  const r = await fetchText(url, {
+    accept: '*/*',
+    'user-agent': DEFAULT_UA,
+    origin: 'https://www.cineby.at',
+    referer: 'https://www.cineby.at/',
+  }, 8000);
+  if (!r || r.status !== 200) return null;
+  try {
+    const j = JSON.parse(r.body);
+    return j.seed || null;
+  } catch { return null; }
+}
+
+// Resolve. opts: { tmdbId, type: 'movie'|'tv', season?, episode?, title, year }
+async function resolve({ tmdbId, type = 'movie', season = 1, episode = 1, title = '', year = '' }) {
+  if (!tmdbId) return { ok: false, error: 'no tmdb id' };
+  const seed = await getSeed(tmdbId);
+  if (!seed) return { ok: false, error: 'seed unavailable' };
+
+  // Build the sources-with-title query (title/mediaType/tmdbId + seasonId/episodeId for series).
+  const params = new URLSearchParams();
+  params.set('title', title || '');
+  params.set('mediaType', type === 'movie' ? 'movie' : 'tv');
+  params.set('tmdbId', String(tmdbId));
+  params.set('_t', String(Date.now()));
+  if (year) params.set('year', String(year));
+  if (type !== 'movie') {
+    params.set('seasonId', String(season));
+    params.set('episodeId', String(episode));
+  }
+  params.set('enc', '2');
+  params.set('seed', seed);
+
+  const url = `${WINGS}/cdn/sources-with-title?${params.toString()}`;
+  const r = await fetchText(url, {
+    accept: '*/*',
+    'user-agent': DEFAULT_UA,
+    origin: 'https://www.cineby.at',
+    referer: 'https://www.cineby.at/',
+  }, 15000);
+  if (!r || r.status !== 200) return { ok: false, error: `sources http ${r ? r.status : 'err'}` };
+
+  let payload;
+  try {
+    const decrypted = decodeWingsdatabasePayload(r.body, seed, tmdbId);
+    payload = JSON.parse(decrypted);
+  } catch (e) {
+    return { ok: false, error: `decrypt failed: ${e.message}` };
+  }
+
+  const streams = [];
+  const sources = payload?.sources || [];
+  const headers = { referer: 'https://www.cineby.at/', 'user-agent': DEFAULT_UA };
+  for (const s of sources) {
+    if (s?.url) {
+      streams.push({ url: s.url, qualityLabel: s?.label || s?.quality || 'auto', headers });
+    }
+  }
+  const subtitles = (payload?.subtitles || []).map((c) => ({
+    url: c?.url,
+    language: c?.lang || c?.label,
+    type: c?.type,
+  }));
+
+  return {
+    ok: streams.length > 0,
+    provider: 'Videasy',
+    streams,
+    subtitles,
+    headers,
+    error: streams.length ? undefined : 'no playable source',
+  };
+}
+
+module.exports = { resolve, name: 'Videasy', getSeed };

package/lib/vidlink.js

@@ -0,0 +1,86 @@
+'use strict';
+// VidLink provider: enc-dec.app encryption -> vidlink.pro/api/b streams.
+const { fetchJson } = require('./helpers');
+
+const ENC_DEC = 'https://enc-dec.app/api/enc-vidlink';
+const API = 'https://vidlink.pro/api/b';
+const UA =
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36';
+
+const encDecCache = new Map();
+
+async function encryptTmdbId(tmdbId) {
+  if (encDecCache.has(tmdbId)) return encDecCache.get(tmdbId);
+  const r = await fetchJson(`${ENC_DEC}?text=${encodeURIComponent(tmdbId)}`, {
+    accept: '*/*',
+    'user-agent': UA,
+    referer: 'https://vidlink.pro/',
+    origin: 'https://vidlink.pro',
+  }, 20000);
+  if (!r.ok || !r.data) return null;
+  const token = typeof r.data === 'string' ? r.data.trim() : r.data.id ?? r.data.token ?? r.data.result;
+  if (token) encDecCache.set(tmdbId, token);
+  return token || null;
+}
+
+// Resolve a stream. opts: { tmdbId, type: 'movie'|'tv', season?, episode? }
+async function resolve({ tmdbId, type = 'movie', season = 1, episode = 1 }) {
+  if (!tmdbId) return { ok: false, error: 'no tmdb id' };
+  const token = await encryptTmdbId(tmdbId);
+  if (!token) return { ok: false, error: 'enc-dec failed' };
+
+  const path = type === 'movie' ? `movie/${token}` : `tv/${token}/${season}/${episode}`;
+  const url = `${API}/${path}`;
+  const headers = {
+    accept: '*/*',
+    'user-agent': UA,
+    referer: 'https://vidlink.pro/',
+    origin: 'https://vidlink.pro',
+    'x-playback-environment': 'webkit',
+  };
+
+  const r = await fetchJson(url, headers, 20000);
+  if (!r.ok) return { ok: false, error: `vidlink ${r.status}` };
+  const stream = r.data?.stream;
+  if (!stream) return { ok: false, error: 'no stream for title' };
+
+  // Collect qualities / playlist into normalized streams.
+  const streams = [];
+  const playlistHeaders = {
+    referer: 'https://vidlink.pro/',
+    origin: 'https://vidlink.pro',
+    'user-agent': UA,
+    ...(stream.playlistHeaders || {}),
+    ...(stream.headers || {}),
+  };
+
+  if (stream.type === 'file' && stream.qualities) {
+    for (const [quality, file] of Object.entries(stream.qualities)) {
+      if (file?.url) streams.push({ url: file.url, qualityLabel: `${quality}p`, headers: playlistHeaders });
+    }
+  }
+  if (stream.playlist) {
+    // multi-quality HLS/DASH: hand the whole playlist to the player so it auto-adapts.
+    const ql = stream.playbackMetadata?.resolutions?.length
+      ? stream.playbackMetadata.resolutions[stream.playbackMetadata.resolutions.length - 1]
+      : 'auto';
+    streams.push({ url: stream.playlist, qualityLabel: ql || 'auto', headers: playlistHeaders });
+  }
+
+  const subtitles = (stream.captions || []).map((c) => ({
+    url: c.url,
+    language: c.language,
+    type: c.type,
+  }));
+
+  return {
+    ok: streams.length > 0,
+    provider: 'VidLink',
+    streams,
+    subtitles,
+    headers: playlistHeaders,
+    error: streams.length ? undefined : 'no playable source',
+  };
+}
+
+module.exports = { resolve, name: 'VidLink' };

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@musabhussainoffical/jelly",
+  "version": "1.0.0",
+  "description": "Jelly — a dependency-free CLI streamer (like ani-cli) that searches movies/series/anime, resolves every provider, and plays in VLC.",
+  "keywords": [
+    "anime",
+    "cli",
+    "ani-cli",
+    "stream",
+    "vlc",
+    "hls",
+    "anidb"
+  ],
+  "license": "MIT",
+  "type": "commonjs",
+  "bin": {
+    "jelly": "bin/jelly.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "lib/anidb.js",
+  "engines": {
+    "node": ">=16"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node test/smoke.js"
+  }
+}