Update index.js

index.js

@@ -1,4 +1,425 @@
-res.type('html').send(`<!DOCTYPE html>
+'use strict';
+
+const express = require('express');
+const axios   = require('axios');
+
+const app  = express();
+const PORT = process.env.PORT || 7860;
+
+app.use((req, res, next) => {
+  res.header('Access-Control-Allow-Origin',  '*');
+  res.header('Access-Control-Allow-Headers', '*');
+  res.header('Access-Control-Allow-Methods', 'GET, OPTIONS');
+  if (req.method === 'OPTIONS') return res.sendStatus(200);
+  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 MAX_SIZE_GB_MOVIE  = 4;
+const MAX_SIZE_GB_SERIES = 1.5;
+const LINKS_PER_QUALITY  = 5;
+const ALLOWED_QUALITIES  = ['4k', '1080p', '720p', '576p', '480p', 'webrip'];
+
+const QUALITY_RANK = {
+  '1080p': 1, '720p': 2, '576p': 3, '480p': 4,
+  '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 TR = [
+  'udp://tracker.opentrackr.org:1337/announce',
+  'udp://open.stealth.si:80/announce',
+  'udp://open.demonii.com:1337/announce',
+  'udp://tracker.torrent.eu.org:451/announce',
+  'udp://p4p.arenabg.com:1337/announce',
+  'udp://exodus.desync.com:6969/announce',
+  'udp://tracker.openbittorrent.com:6969/announce',
+  'udp://tracker.dler.org:6969/announce',
+  'https://tracker.moeblog.cn:443/announce',
+  'https://tracker.zhuqiy.com:443/announce',
+].map(t => '&tr=' + encodeURIComponent(t)).join('');
+
+function buildMagnet(hash, name) {
+  return 'magnet:?xt=urn:btih:' + hash.toLowerCase() + '&dn=' + encodeURIComponent(name) + TR;
+}
+
+function getQuality(str = '') {
+  const s = str.toLowerCase();
+  if (s.includes('4k') || s.includes('2160p') || s.includes('uhd')) return '4k';
+  if (s.includes('1080p'))  return '1080p';
+  if (s.includes('720p'))   return '720p';
+  if (s.includes('576p'))   return '576p';
+  if (s.includes('480p'))   return '480p';
+  if (s.includes('webrip')) return 'webrip';
+  if (s.includes('webdl') || s.includes('web-dl')) return 'webdl';
+  return null;
+}
+
+function getSizeGB(stream) {
+  const raw = stream.title || stream.name || '';
+  const m   = raw.match(/💾\s*([\d.]+)\s*(GB|MB)/i) || raw.match(/([\d.]+)\s*(GB|MB)/i);
+  if (!m) return null;
+  const val = parseFloat(m[1]);
+  return m[2].toUpperCase() === 'GB' ? val : val / 1024;
+}
+
+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+)/);
+  return m ? parseInt(m[1], 10) : 0;
+}
+
+function getLangLine(str = '') {
+  const lower = str.toLowerCase();
+  const found = [];
+  const checks = [
+    [/\benglish\b/,           'English'],
+    [/\bjapanese\b/,          'Japanese'],
+    [/\bhindi\b/,             'Hindi'],
+    [/\bfrench\b/,            'French'],
+    [/\bgerman\b/,            'German'],
+    [/\bspanish\b/,           'Spanish'],
+    [/\bitalian\b/,           'Italian'],
+    [/\brussian\b/,           'Russian'],
+    [/\bkorean\b/,            'Korean'],
+    [/\bchinese\b/,           'Chinese'],
+    [/\barabic\b/,            'Arabic'],
+    [/\bportuguese\b/,        'Portuguese'],
+    [/\bturkish\b/,           'Turkish'],
+    [/\bpolish\b/,            'Polish'],
+    [/\bdutch\b/,             'Dutch'],
+    [/\bczech\b/,             'Czech'],
+    [/\bswedish\b/,           'Swedish'],
+    [/\bnorwegian\b/,         'Norwegian'],
+    [/\bdanish\b/,            'Danish'],
+    [/\bfinnish\b/,           'Finnish'],
+    [/\bromanian\b/,          'Romanian'],
+    [/\bgreek\b/,             'Greek'],
+    [/\bhebrew\b/,            'Hebrew'],
+    [/\bthai\b/,              'Thai'],
+    [/\bindonesian\b/,        'Indonesian'],
+    [/\bvietnamese\b/,        'Vietnamese'],
+    [/\btamil\b/,             'Tamil'],
+    [/\btelugu\b/,            'Telugu'],
+    [/\burdu\b/,              'Urdu'],
+    [/\bdubbed\b/,            'Dubbed'],
+    [/\bdual[\s\-]audio\b/,   'Dual Audio'],
+    [/\bmulti[\s\-]audio\b/,  'Multi Audio'],
+    [/\bmulti\b/,             'Multi'],
+  ];
+  for (const [re, label] of checks) {
+    if (re.test(lower)) {
+      if (label === 'Multi' && found.includes('Multi Audio')) continue;
+      found.push(label);
+    }
+  }
+  return [...new Set(found)].join(' / ');
+}
+
+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);
+    if (sizeGB !== null && sizeGB > maxSize) return false;
+    return true;
+  });
+
+  const seen   = new Set();
+  const unique = filtered.filter(s => {
+    const key = (s.infoHash || '').toLowerCase();
+    if (!key) return true;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+
+  const byQuality = {};
+  unique.forEach(s => {
+    const q = s._quality || getQuality(s.title || s.name || '') || 'unknown';
+    if (!byQuality[q]) byQuality[q] = [];
+    byQuality[q].push(s);
+  });
+
+  for (const q in byQuality) {
+    byQuality[q].sort((a, b) => {
+      const rankA = PRIORITY_PROVIDERS.indexOf((a._source || '').toLowerCase());
+      const rankB = PRIORITY_PROVIDERS.indexOf((b._source || '').toLowerCase());
+      const pA = rankA === -1 ? 999 : rankA;
+      const pB = rankB === -1 ? 999 : rankB;
+      if (pA !== pB) return pA - pB;
+      return getSeeders(b) - getSeeders(a);
+    });
+  }
+
+  const sortedQualities = Object.keys(byQuality).sort(
+    (a, b) => (QUALITY_RANK[a] || 99) - (QUALITY_RANK[b] || 99)
+  );
+
+  const result = [];
+  sortedQualities.forEach(q => result.push(...byQuality[q].slice(0, LINKS_PER_QUALITY)));
+  return result;
+}
+
+async function tmdbLookup(imdbId) {
+  try {
+    const { data } = await axios.get(
+      `https://api.themoviedb.org/3/find/${imdbId}?api_key=${TMDB_KEY}&external_source=imdb_id`,
+      { timeout: 8000 }
+    );
+    const movie = data.movie_results?.[0];
+    const tv    = data.tv_results?.[0];
+    if (movie) return { title: movie.title || movie.original_title, year: (movie.release_date || '').slice(0, 4) };
+    if (tv)    return { title: tv.name || tv.original_name, year: (tv.first_air_date || '').slice(0, 4) };
+    return null;
+  } catch (e) { console.error('[TMDB]', e.message); return null; }
+}
+
+// ─── TorrentClaw scraper ───────────────────────────────────────────────
+async function scrapeTorrentClaw(type, imdbId, title, year, season, episode) {
+  try {
+    const isSeries = type === 'series';
+    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' },
+    });
+
+    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 rawDesc  = item.description || '';
+      const combined = `${rawName} ${rawTitle} ${rawDesc}`.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;
+
+      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 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 langLine = getLangLine(combined);
+
+      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 : ''}`,
+        sources:  [],
+        _quality: getQuality(combined),
+        _seeders: seeders,
+        _sizeGB:  sizeGB,
+        _source:  'torrentclaw',
+        _provider: 'torrentclaw',
+      });
+    }
+    console.log(`[TorrentClaw] ${streams.length} for ${type}/${imdbId}`);
+    return streams;
+  } catch (e) { console.error('[TorrentClaw]', e.message); return []; }
+}
+
+// ─── Torrentio scraper ────────────────────────────────────────────────
+async function scrapeTorrentio(type, imdbId, 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);
+
+      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:  [],
+        _quality: quality,
+        _seeders: seeders,
+        _sizeGB:  sizeGB,
+        _source:  provider,
+        _provider: provider,
+      });
+    }
+    console.log(`[Torrentio] ${streams.length} for ${type}/${imdbId}`);
+    return streams;
+  } catch (e) { console.error('[Torrentio]', e.message); return []; }
+}
+
+// ─── Manifest ──────────────────────────────────────────────────────────
+app.get('/manifest.json', (_, res) => {
+  res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate');
+  res.json({
+    id:          'org.ghostream.plus.v2',
+    name:        'VanStreams+',
+    description: 'Stream Everything You Want\nMade With 🤍 By Van',
+    version:     '15.0.7',
+    resources:   ['stream'],
+    types:       ['movie', 'series'],
+    idPrefixes:  ['tt'],
+    catalogs:    [],
+  });
+});
+
+// ─── Stream handler ────────────────────────────────────────────────
+app.get('/stream/:type/:id.json', async (req, res) => {
+  const { type, id } = req.params;
+  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([
+    scrapeTorrentClaw(type, imdbId, title, year, season, episode),
+    scrapeTorrentio(type, imdbId, title, year, season, episode)
+  ]);
+
+  const combinedStreams = [...torrentclaw, ...torrentio];
+  const streams = processStreams(combinedStreams, type);
+
+  console.log(`[stream] ${type}/${id} → torrentclaw:${torrentclaw.length} torrentio:${torrentio.length} combined:${combinedStreams.length} final:${streams.length}`);
+  res.json({ streams });
+});
+
+// ─── Diagnostic endpoints ─────────────────────────────────────────────
+app.get('/diag/:type/:id', async (req, res) => {
+  const { type, id } = req.params;
+  const [imdbId, season = '', episode = ''] = id.split(':');
+  const meta = await tmdbLookup(imdbId);
+
+  const [torrentclaw, torrentio] = await Promise.all([
+    scrapeTorrentClaw(type, imdbId, meta?.title || '', meta?.year || '', season, episode),
+    scrapeTorrentio(type, imdbId, meta?.title || '', meta?.year || '', season, episode)
+  ]);
+
+  res.json({
+    imdbId, title: meta?.title, year: meta?.year, isSeries: type === 'series',
+    tmdb:        meta ? `OK: ${meta.title} (${meta.year})` : 'FAILED',
+    torrentclaw: { count: torrentclaw.length },
+    torrentio:   { count: torrentio.length }
+  });
+});
+
+app.get('/diag-raw/:type/:id', async (req, res) => {
+  const { type, id } = req.params;
+  try {
+    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' } })
+    ]);
+
+    res.json({
+      torrentclaw: (clawRes.data?.streams || []).slice(0, 3),
+      torrentio:   (tioRes.data?.streams || []).slice(0, 3)
+    });
+  } catch (e) { res.json({ error: e.message }); }
+});
+
+// ══════════════════════════  LANDING PAGE  ═══════════════════════════
+app.get('/', (req, res) => {
+  const manifestUrl = 'https://vanseleem-vsplus.hf.space/manifest.json';
+  const installUrl  = 'stremio://vanseleem-vsplus.hf.space/manifest.json';
+
+  res.type('html').send(`<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="UTF-8">