Update index.js

index.js

@@ -17,7 +17,11 @@ app.use((req, res, next) => {
 const TMDB_KEY         = '83d364331c40bfbe29858aeed82f45cc';
 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 TORRENTCLAW_API  = 'https://torrentclaw.com/api/stremio';
-const TORRENTIO_API    = 'https://torrentio.strem.fun';
+const TORRENTIO_BASE   = 'https://torrentio.strem.fun';
+
+const PROXY_1 = 'https://corsproxy.io/?url=';
+const PROXY_2 = 'https://api.codetabs.com/v1/proxy?quest=';
+const PROXY_3 = 'https://thingproxy.freeboard.io/fetch/';
 
 const MAX_SIZE_GB_MOVIE  = 4;
 const MAX_SIZE_GB_SERIES = 1.5;
@@ -29,25 +33,9 @@ const QUALITY_RANK = {
   '4k': 5, '2160p': 5, 'webrip': 6, 'webdl': 6,
 };
 
-const PRIORITY_PROVIDERS = ['yts', 'knaben', 'torrentsdb', 'eztv', 'nyaasi', 'thepiratebay', 'torrentclaw', 'torrentio'];
-
-const ALLOWED_PROVIDERS = [
-  'yts',
-  'knaben',
-  'thepiratesbay',
-  'thepiratebay',
-  'eztv',
-  'torrentcsv',
-  'nyaa',
-  'nyaasi',
-  'limetorrent',
-  'kickasstorrents',
-  'animetosho',
-  'tokyotosho',
-  'torrentclaw',
-  'torrentio',
-  'unknown'
-];
+const PRIORITY_PROVIDERS = ['yts', 'knaben', 'torrentsdb', 'eztv', 'nyaasi', 'thepiratebay', 'torrentclaw'];
+
+// NOTE: ALLOWED_PROVIDERS removed on request — no provider is filtered out.
 
 const TR = [
   'udp://tracker.opentrackr.org:1337/announce',
@@ -66,6 +54,27 @@ function buildMagnet(hash, name) {
   return 'magnet:?xt=urn:btih:' + hash.toLowerCase() + '&dn=' + encodeURIComponent(name) + TR;
 }
 
+// ─── Proxy fallback (used by Torrentio, same as the original script) ───
+async function fetchWithProxy(url, options = {}) {
+  const proxies = [
+    url,
+    PROXY_1 + encodeURIComponent(url),
+    PROXY_2 + encodeURIComponent(url),
+    PROXY_3 + encodeURIComponent(url),
+  ];
+
+  for (const proxyUrl of proxies) {
+    try {
+      const response = await axios.get(proxyUrl, { timeout: 12000, headers: { 'User-Agent': UA }, ...options });
+      return response;
+    } catch (e) {
+      console.warn(`[Proxy] Failed: ${proxyUrl.substring(0, 50)}... Error: ${e.message}`);
+      continue;
+    }
+  }
+  throw new Error('All proxy attempts failed');
+}
+
 function getQuality(str = '') {
   const s = str.toLowerCase();
   if (s.includes('4k') || s.includes('2160p') || s.includes('uhd')) return '4k';
@@ -89,7 +98,7 @@ function getSizeGB(stream) {
 function getSeeders(stream) {
   if (stream._seeders != null) return stream._seeders;
   if (stream.behaviorHints?.seeders) return stream.behaviorHints.seeders;
-  const m = (stream.title || '').match(/👤\s*(\d+)/);
+  const m = (stream.title || '').match(/🌱\s*(\d+)/) || (stream.title || '').match(/👤\s*(\d+)/);
   return m ? parseInt(m[1], 10) : 0;
 }
 
@@ -140,12 +149,44 @@ function getLangLine(str = '') {
   return [...new Set(found)].join(' / ');
 }
 
+// ─── Unified TorrentClaw-style title template ──────────────────────────
+// Used by BOTH TorrentClaw and Torrentio so every stream in the list looks
+// consistent, matching the original TorrentClaw addon's format:
+//   🎦 Title | S1 E1          (series)  /  🎬 Title - 2026        (movie)
+//   🔥 1080p | HDR10 • HEVC • English
+//   🌱 42 | 💾 1.2 GB | 🔗 YTS
+function qualityEmoji(quality) {
+  switch (quality) {
+    case '4k':
+    case '2160p': return '🌟';
+    case '1080p': return '🔥';
+    case '720p':  return '💎';
+    case '576p':
+    case '480p':  return '📱';
+    case 'webrip':
+    case 'webdl': return '🌐';
+    default:      return '🔥';
+  }
+}
+
+function buildUnifiedTitle({ isSeries, title, year, season, episode, quality, tagLine, seeders, sizeStr, provider }) {
+  const header  = isSeries
+    ? `🎦 ${title} | S${season || 1} E${episode || 1}`
+    : `🎬 ${title}${year ? ' - ' + year : ''}`;
+  const qLine   = `${qualityEmoji(quality)} ${quality || 'unknown'}${tagLine ? ' | ' + tagLine : ''}`;
+  const statsLine = `🌱 ${seeders} | 💾 ${sizeStr} | 🔗 ${provider}`;
+  return `${header}\n${qLine}\n${statsLine}`;
+}
+
+function buildUnifiedName({ quality, seeders, sourceLabel }) {
+  return `${sourceLabel} | ${(quality || 'unknown').toUpperCase()} | 🌱${seeders}`;
+}
+
 function processStreams(streams, type) {
   const maxSize = type === 'series' ? MAX_SIZE_GB_SERIES : MAX_SIZE_GB_MOVIE;
 
   const filtered = streams.filter(s => {
     if (!s.infoHash && !s.url) return false;
-    if (s._provider && !ALLOWED_PROVIDERS.includes(s._provider.toLowerCase())) return false;
     const q = s._quality || getQuality(s.title || s.name || '');
     if (!q || !ALLOWED_QUALITIES.includes(q)) return false;
     const sizeGB = s._sizeGB ?? getSizeGB(s);
@@ -203,7 +244,7 @@ async function tmdbLookup(imdbId) {
   } catch (e) { console.error('[TMDB]', e.message); return null; }
 }
 
-// ─── TorrentClaw scraper ───────────────────────────────────────────────
+// ─── TorrentClaw scraper ─────────────────────────────────────────────
 async function scrapeTorrentClaw(type, imdbId, title, year, season, episode) {
   try {
     const isSeries = type === 'series';
@@ -227,6 +268,7 @@ async function scrapeTorrentClaw(type, imdbId, title, year, season, episode) {
       const rawTitle = item.title || '';
       const rawDesc  = item.description || '';
       const combined = `${rawName} ${rawTitle} ${rawDesc}`.replace(/\n/g, ' ');
+      const upper    = combined.toUpperCase();
 
       const infoHashMatch = (item.url || '').match(/btih:([a-fA-F0-9]{32,40})/i);
       const infoHash = item.infoHash || (infoHashMatch ? infoHashMatch[1] : null);
@@ -235,22 +277,40 @@ async function scrapeTorrentClaw(type, imdbId, title, year, season, episode) {
       const sizeGB = getSizeGB({ title: combined })
         ?? (typeof item.size === 'number' ? item.size / 1073741824 : null)
         ?? (typeof item.bytes === 'number' ? item.bytes / 1073741824 : null);
-      const sizeStr = sizeGB ? sizeGB.toFixed(2) + ' GB' : 'N/A';
+      const sizeStr = sizeGB ? sizeGB.toFixed(2) + ' GB' : 'Unknown Size';
 
       const seeders = typeof item.seeders === 'number'
         ? item.seeders
         : (() => { const m = combined.match(/🌱\s*(\d+)/) || combined.match(/👤\s*(\d+)/) || combined.match(/(\d+)\s*seed/i); return m ? parseInt(m[1], 10) : 0; })();
 
-      const provider = (item.provider || item.source || item.indexer || 'TorrentClaw').toString().toLowerCase();
+      const provider = (item.provider || item.source || item.indexer || 'TorrentClaw').toString();
+      const quality  = getQuality(combined) || getQuality(upper);
+
+      // Build a HEVC/HDR/DV/audio tag line, same spirit as the original TorrentClaw output
+      const tags = [];
+      if (upper.includes('DV') || upper.includes('DOLBY VISION')) tags.push('DV');
+      if (upper.includes('HDR10+')) tags.push('HDR10+');
+      else if (upper.includes('HDR10')) tags.push('HDR10');
+      else if (upper.includes('HDR')) tags.push('HDR');
+      if (upper.includes('HEVC') || upper.includes('X265') || upper.includes('H265')) tags.push('HEVC');
       const langLine = getLangLine(combined);
+      if (langLine) tags.push(langLine);
+      else tags.push('English');
+      const tagLine = tags.join(' • ');
+
+      const unifiedTitle = buildUnifiedTitle({
+        isSeries: type === 'series', title, year, season, episode,
+        quality, tagLine, seeders, sizeStr, provider,
+      });
+      const unifiedName = buildUnifiedName({ quality, seeders, sourceLabel: '🦞 TorrentClaw' });
 
       streams.push({
         infoHash: infoHash ? infoHash.toLowerCase() : undefined,
         url:      infoHash ? undefined : item.url,
-        name:     rawName || rawTitle,
-        title:    `☀️ ${title}${year ? ' (' + year + ')' : ''}\n🌱 ${seeders}\n💾 ${sizeStr}\n🏅 TorrentClaw${langLine ? '\n🔊 ' + langLine : ''}`,
+        name:     unifiedName,
+        title:    unifiedTitle,
         sources:  [],
-        _quality: getQuality(combined),
+        _quality: quality,
         _seeders: seeders,
         _sizeGB:  sizeGB,
         _source:  'torrentclaw',
@@ -262,80 +322,58 @@ async function scrapeTorrentClaw(type, imdbId, title, year, season, episode) {
   } catch (e) { console.error('[TorrentClaw]', e.message); return []; }
 }
 
-// ─── Torrentio scraper ────────────────────────────────────────────────
-async function scrapeTorrentio(type, imdbId, title, year, season, episode) {
+// ─── Torrentio scraper (config/logic from the original Torrentio script) ─
+async function fetchTorrentio(type, id, title, year, season, episode) {
   try {
-    const isSeries = type === 'series';
-    const path      = isSeries
-      ? `series/${imdbId}:${season || 1}:${episode || 1}`
-      : `movie/${imdbId}`;
-    const url = `${TORRENTIO_API}/stream/${path}.json`;
-
-    const { data } = await axios.get(url, {
-      timeout: 15000,
-      headers: { 'User-Agent': UA, 'Accept': 'application/json' },
-    });
-
-    if (!data || !Array.isArray(data.streams) || data.streams.length === 0) return [];
-
-    const streams = [];
-    for (const item of data.streams) {
-      if (!item) continue;
-
-      const rawName  = item.name || '';
-      const rawTitle = item.title || '';
-      const combined = `${rawName} ${rawTitle}`.replace(/\n/g, ' ');
-
-      const infoHashMatch = (item.url || '').match(/btih:([a-fA-F0-9]{32,40})/i);
-      const infoHash = item.infoHash || (infoHashMatch ? infoHashMatch[1] : null);
-      if (!infoHash && !item.url) continue;
-
-      // Extract size
-      let sizeGB = null;
-      let sizeStr = 'N/A';
-      const sizeMatch = combined.match(/([0-9.]+ ?[GM]B)/i);
-      if (sizeMatch) {
-        const val = parseFloat(sizeMatch[1]);
-        sizeGB = sizeMatch[2].toUpperCase() === 'GB' ? val : val / 1024;
-        sizeStr = sizeGB.toFixed(2) + ' GB';
-      }
-
-      // Extract seeders
-      const seedersMatch = combined.match(/👤\s*(\d+)/);
-      const seeders = seedersMatch ? parseInt(seedersMatch[1], 10) : 0;
-
-      // Extract provider (matching Script 2 logic)
-      let provider = 'torrentio';
-      const providerMatch = combined.match(/⚙️\s*([^👤💾\n]+)/);
-      if (providerMatch) {
-        provider = providerMatch[1].trim();
-      } else {
-        if (combined.includes('RARBG')) provider = 'RARBG';
-        else if (combined.includes('YTS')) provider = 'YTS';
-        else if (combined.includes('TPB') || combined.includes('ThePirateBay')) provider = 'ThePirateBay';
-        else if (combined.includes('1337X')) provider = '1337x';
-        else if (combined.includes('EZTV')) provider = 'EZTV';
-        else if (combined.includes('TGX')) provider = 'TGX';
-      }
-      provider = provider.toLowerCase();
-
-      const quality  = getQuality(combined);
-      const langLine = getLangLine(combined);
+    const url = `${TORRENTIO_BASE}/stream/${type}/${id}.json`;
+    const { data } = await fetchWithProxy(url);
+
+    const streams = (data.streams || []).map(s => {
+      const origTitle = s.title || '';
+      const providerMatch = origTitle.match(/⚙️\s*(\S+)/);
+      let provider = providerMatch ? providerMatch[1] : 'Unknown';
+      provider = provider.toLowerCase().replace(/\.(to|com|org|net|io)$/, '');
+      if (provider === 'thepiratebay') provider = 'thepiratesbay';
+      if (provider === 'nyaa.si') provider = 'nyaa';
+      if (provider === 'limetorrents') provider = 'limetorrent';
+      if (provider === 'kat') provider = 'kickasstorrents';
+
+      const seeders = s.behaviorHints?.seeders
+        ?? (() => { const m = origTitle.match(/👤\s*(\d+)/) || origTitle.match(/🌱\s*(\d+)/); return m ? parseInt(m[1], 10) : 0; })();
+      const sizeGB  = getSizeGB(s);
+      const sizeStr = sizeGB ? sizeGB.toFixed(2) + ' GB' : 'Unknown Size';
+      const quality = getQuality(origTitle) || getQuality(s.name || '');
+
+      const upper = origTitle.toUpperCase();
+      const tags = [];
+      if (upper.includes('DV') || upper.includes('DOLBY VISION')) tags.push('DV');
+      if (upper.includes('HDR10+')) tags.push('HDR10+');
+      else if (upper.includes('HDR10')) tags.push('HDR10');
+      else if (upper.includes('HDR')) tags.push('HDR');
+      if (upper.includes('HEVC') || upper.includes('X265') || upper.includes('H265')) tags.push('HEVC');
+      const langLine = getLangLine(origTitle);
+      if (langLine) tags.push(langLine);
+      else tags.push('English');
+      const tagLine = tags.join(' • ');
+
+      const unifiedTitle = buildUnifiedTitle({
+        isSeries: type === 'series', title, year, season, episode,
+        quality, tagLine, seeders, sizeStr, provider,
+      });
+      const unifiedName = buildUnifiedName({ quality, seeders, sourceLabel: '⚙️ Torrentio' });
 
-      streams.push({
-        infoHash: infoHash ? infoHash.toLowerCase() : undefined,
-        url:      infoHash ? undefined : item.url,
-        name:     rawName || 'Torrentio',
-        title:    `☀️ ${title}${year ? ' (' + year + ')' : ''}\n🌱 ${seeders}\n💾 ${sizeStr}\n🏅 ${provider}${langLine ? '\n🔊 ' + langLine : ''}`,
-        sources:  [],
+      return {
+        ...s,
+        name:     unifiedName,
+        title:    unifiedTitle,
         _quality: quality,
         _seeders: seeders,
         _sizeGB:  sizeGB,
-        _source:  provider,
+        _source:  'torrentio',
         _provider: provider,
-      });
-    }
-    console.log(`[Torrentio] ${streams.length} for ${type}/${imdbId}`);
+      };
+    });
+    console.log(`[Torrentio] ${streams.length} for ${type}/${id}`);
     return streams;
   } catch (e) { console.error('[Torrentio]', e.message); return []; }
 }
@@ -358,59 +396,65 @@ app.get('/manifest.json', (_, res) => {
 // ─── Stream handler ────────────────────────────────────────────────
 app.get('/stream/:type/:id.json', async (req, res) => {
   const { type, id } = req.params;
+  const isSeries = type === 'series';
   const [imdbId, season = '', episode = ''] = id.split(':');
 
   const meta  = await tmdbLookup(imdbId);
   const title = meta?.title || '';
   const year  = meta?.year  || '';
 
-  // Fetch from both providers in parallel
-  const [torrentclaw, torrentio] = await Promise.all([
+  const [torrentclawR, torrentioR] = await Promise.allSettled([
     scrapeTorrentClaw(type, imdbId, title, year, season, episode),
-    scrapeTorrentio(type, imdbId, title, year, season, episode)
+    fetchTorrentio(type, id, title, year, season, episode),
   ]);
 
-  const combinedStreams = [...torrentclaw, ...torrentio];
-  const streams = processStreams(combinedStreams, type);
+  const torrentclaw = torrentclawR.status === 'fulfilled' ? (torrentclawR.value || []) : [];
+  const torrentio    = torrentioR.status    === 'fulfilled' ? (torrentioR.value    || []) : [];
 
-  console.log(`[stream] ${type}/${id} → torrentclaw:${torrentclaw.length} torrentio:${torrentio.length} combined:${combinedStreams.length} final:${streams.length}`);
+  const streams = processStreams([...torrentclaw, ...torrentio], type);
+
+  console.log(`[stream] ${type}/${id} → torrentclaw:${torrentclaw.length} torrentio:${torrentio.length} final:${streams.length}`);
   res.json({ streams });
 });
 
 // ─── Diagnostic endpoints ─────────────────────────────────────────────
 app.get('/diag/:type/:id', async (req, res) => {
   const { type, id } = req.params;
+  const isSeries = type === 'series';
   const [imdbId, season = '', episode = ''] = id.split(':');
   const meta = await tmdbLookup(imdbId);
-
-  const [torrentclaw, torrentio] = await Promise.all([
+  const [torrentclawR, torrentioR] = await Promise.allSettled([
     scrapeTorrentClaw(type, imdbId, meta?.title || '', meta?.year || '', season, episode),
-    scrapeTorrentio(type, imdbId, meta?.title || '', meta?.year || '', season, episode)
+    fetchTorrentio(type, id, meta?.title || '', meta?.year || '', season, episode),
   ]);
-
   res.json({
-    imdbId, title: meta?.title, year: meta?.year, isSeries: type === 'series',
+    imdbId, title: meta?.title, year: meta?.year, isSeries,
     tmdb:        meta ? `OK: ${meta.title} (${meta.year})` : 'FAILED',
-    torrentclaw: { count: torrentclaw.length },
-    torrentio:   { count: torrentio.length }
+    torrentclaw: { count: (torrentclawR.value || []).length, err: torrentclawR.reason?.message || null },
+    torrentio:   { count: (torrentioR.value    || []).length, err: torrentioR.reason?.message    || null },
   });
 });
 
-app.get('/diag-raw/:type/:id', async (req, res) => {
+app.get('/diag-raw/torrentclaw/:type/:id', async (req, res) => {
   const { type, id } = req.params;
   try {
+    const isSeries = type === 'series';
     const [imdbId, season = '', episode = ''] = id.split(':');
-    const path = type === 'series' ? `series/${imdbId}:${season || 1}:${episode || 1}` : `movie/${imdbId}`;
-
-    const [clawRes, tioRes] = await Promise.all([
-      axios.get(`${TORRENTCLAW_API}/stream/${path}.json`, { timeout: 15000, headers: { 'User-Agent': UA, 'Accept': 'application/json' } }),
-      axios.get(`${TORRENTIO_API}/stream/${path}.json`, { timeout: 15000, headers: { 'User-Agent': UA, 'Accept': 'application/json' } })
-    ]);
+    const path = isSeries ? `series/${imdbId}:${season || 1}:${episode || 1}` : `movie/${imdbId}`;
+    const url = `${TORRENTCLAW_API}/stream/${path}.json`;
+    const { data } = await axios.get(url, { timeout: 15000, headers: { 'User-Agent': UA, 'Accept': 'application/json' } });
+    res.json((data.streams || []).slice(0, 3));
+  } catch (e) { res.json({ error: e.message }); }
+});
 
-    res.json({
-      torrentclaw: (clawRes.data?.streams || []).slice(0, 3),
-      torrentio:   (tioRes.data?.streams || []).slice(0, 3)
-    });
+app.get('/diag-raw/torrentio/:type/:id', async (req, res) => {
+  const { type, id } = req.params;
+  try {
+    const url = `${TORRENTIO_BASE}/stream/${type}/${id}.json`;
+    const { data } = await fetchWithProxy(url);
+    res.json((data.streams || []).slice(0, 3).map(s => ({
+      name: s.name, title: s.title, behaviorHints: s.behaviorHints,
+    })));
   } catch (e) { res.json({ error: e.message }); }
 });