Update index.js

index.js

@@ -1,202 +1,352 @@
+'use strict';
+
 const express = require('express');
-const fetch = require('node-fetch');
+const fetch   = require('node-fetch');
 
-const app = express();
+const app  = express();
 const PORT = process.env.PORT || 7860;
 
+// ─── CORS ──────────────────────────────────────────────────────────────────────
 app.use((req, res, next) => {
-  res.header('Access-Control-Allow-Origin', '*');
+  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();
 });
 
+// ─── CONFIG ────────────────────────────────────────────────────────────────────
+
 const UPSTREAM_URLS = [
-  'https://torrentio.strem.fun',
-  'https://torrentio.stremio.my.id'
+  'https://torrentio.strem.fun/providers=eztv,thepiratebay,nyaasi|qualityfilter=scr,cam,threed,unknown',
+  'https://vanseleem-gsplus.hf.space/',
 ];
 
-const MIN_SEEDERS = 1;
-const ALLOWED_QUALITIES = ['480p', '576p', '720p', '1080p', 'webrip', 'webdl', 'bluray'];
-const MAX_SIZE_GB_MOVIE = 4;
+const SUBTITLES_URL = 'https://vanseleem-vansubs.hf.space';
+
+const MIN_SEEDERS        = 2;
+const BLOCK_SIZELESS     = true;
+const MAX_SIZE_GB_MOVIE  = 4;
 const MAX_SIZE_GB_SERIES = 1.5;
+const LINKS_PER_QUALITY  = 5;
+const FETCH_TIMEOUT_MS   = 12_000;
+
+const ALLOWED_QUALITIES = ['4k', '2160p', '1080p', '720p', '576p', '480p'];
 
 const SOURCE_CONFIG = [
-  { name: 'yts', display: 'YTS', order: 1 },
-  { name: 'yify', display: 'YTS', order: 1 },
-  { name: 'eztv', display: 'EZTV', order: 2 },
-  { name: 'nyaasi', display: 'Nyaa', order: 3 },
-  { name: 'thepiratebay', display: 'TPB', order: 4 },
-  { name: 'piratebay', display: 'TPB', order: 4 },
-  { name: 'the piratebay', display: 'TPB', order: 4 },
-  { name: 'tpb', display: 'TPB', order: 4 },
-  { name: '1337x', display: '1337x', order: 5 },
-  { name: 'torrentgalaxy', display: 'TGx', order: 6 },
-  { name: 'rarbg', display: 'RARBG', order: 7 },
-  { name: 'rutor', display: 'Rutor', order: 8 },
-  { name: 'rutracker', display: 'Rutracker', order: 9 }
+  { name: 'yts',          display: 'YTS',    order: 1 },
+  { name: 'yify',         display: 'YTS',    order: 1 },
+  { name: 'knaben',       display: 'Knaben', order: 2 },
+  { name: 'eztv',         display: 'EZTV',   order: 3 },
+  { name: 'nyaasi',       display: 'Nyaa',   order: 4 },
+  { name: 'thepiratebay', display: 'TPB',    order: 5 },
+  { name: 'piratebay',    display: 'TPB',    order: 5 },
+  { name: 'the piratebay',display: 'TPB',    order: 5 },
+  { name: 'tpb',          display: 'TPB',    order: 5 },
+];
+
+const BLOCKED_PROVIDERS = [
+  'rarbg', '1337x', 'kickasstorrents', 'torrentgalaxy', 'magnetdl',
+  'horriblesubs', 'tokyotosho', 'anidex', 'rutor', 'rutracker',
+  'comando', 'bludv', 'micoleaodublado',
+  'torrent9', 'ilcorsaronero',
+  'mejortorrent', 'wolfmax4k', 'cinecalidad', 'besttorrents',
 ];
 
 const QUALITY_RANK = {
-  '1080p': 1,
-  '720p': 2,
-  'webdl': 3,
-  'webrip': 4,
-  '576p': 5,
-  '480p': 6,
-  'bluray': 7
+  '4k': 1, '2160p': 1,
+  '1080p': 2,
+  '720p':  3,
+  'webdl': 4, 'webrip': 4,
+  '576p':  5,
+  '480p':  6,
+  'bluray': 7,
 };
 
-const LINKS_PER_QUALITY = 5;
+// ─── STREAM HELPERS ────────────────────────────────────────────────────────────
 
 function getQuality(title = '') {
-  const lower = title.toLowerCase();
-  if (lower.includes('1080p')) return '1080p';
-  if (lower.includes('720p')) return '720p';
-  if (lower.includes('480p')) return '480p';
-  if (lower.includes('576p')) return '576p';
-  if (lower.includes('webrip')) return 'webrip';
-  if (lower.includes('webdl') || lower.includes('web-dl')) return 'webdl';
-  if (lower.includes('bluray')) return 'bluray';
+  const t = title.toLowerCase();
+  if (t.includes('4k') || t.includes('2160p')) return '4k';
+  if (t.includes('1080p'))                      return '1080p';
+  if (t.includes('720p'))                       return '720p';
+  if (t.includes('576p'))                       return '576p';
+  if (t.includes('480p'))                       return '480p';
+  if (t.includes('webrip'))                     return 'webrip';
+  if (t.includes('webdl') || t.includes('web-dl')) return 'webdl';
+  if (t.includes('bluray'))                     return 'bluray';
   return null;
 }
 
 function getSeeders(stream) {
   if (stream.behaviorHints?.seeders) return stream.behaviorHints.seeders;
-  const match = stream.title?.match(/👤\s*(\d+)/);
-  return match ? parseInt(match[1], 10) : 0;
+  const m = (stream.title || '').match(/👤\s*(\d+)/);
+  return m ? parseInt(m[1], 10) : 0;
 }
 
-function getSizeInGB(stream) {
+function getSizeGB(stream) {
   const title = stream.title || '';
-  const sizeMatch = title.match(/💾\s*([\d.]+)\s*(GB|MB)/i) || 
-                    title.match(/([\d.]+)\s*(GB|MB)/i);
-  if (!sizeMatch) return null;
-  
-  const value = parseFloat(sizeMatch[1]);
-  const unit = sizeMatch[2].toUpperCase();
-  
-  if (unit === 'GB') return value;
-  if (unit === 'MB') return value / 1024;
-  return null;
+  const m = title.match(/💾\s*([\d.]+)\s*(GB|MB)/i) ||
+            title.match(/([\d.]+)\s*(GB|MB)/i);
+  if (!m) return null;
+  const val  = parseFloat(m[1]);
+  const unit = m[2].toUpperCase();
+  return unit === 'GB' ? val : val / 1024;
 }
 
 function detectSource(title = '') {
   const lower = title.toLowerCase();
   for (const src of SOURCE_CONFIG) {
-    if (lower.includes(src.name)) return src.name;
+    if (lower.includes(src.name)) return src;
   }
   return null;
 }
 
-function getSourceOrder(sourceName) {
-  const config = SOURCE_CONFIG.find(c => c.name === sourceName);
-  return config ? config.order : 999;
+function isBlocked(stream) {
+  const haystack = (
+    (stream.behaviorHints?.bingeGroup || '') + ' ' +
+    (stream.title || '') + ' ' +
+    (stream.name  || '')
+  ).toLowerCase();
+  return BLOCKED_PROVIDERS.some(p => haystack.includes(p));
 }
 
-function filterStream(stream, type = 'movie') {
-  const title = stream.title || '';
+// ─── FILTER & SORT ─────────────────────────────────────────────────────────────
+
+function filterStream(stream, type) {
   if (!stream.url && !stream.infoHash) return false;
-  
-  const quality = getQuality(title);
-  if (!ALLOWED_QUALITIES.includes(quality)) return false;
-  
+  if (isBlocked(stream))               return false;
+
+  const quality = getQuality(stream.title);
+  if (!quality || !ALLOWED_QUALITIES.includes(quality)) return false;
+
   if (getSeeders(stream) < MIN_SEEDERS) return false;
-  
-  if (!detectSource(title)) return false;
-  
+
+  const sizeGB = getSizeGB(stream);
+  if (BLOCK_SIZELESS && sizeGB === null) return false;
   const maxSize = type === 'series' ? MAX_SIZE_GB_SERIES : MAX_SIZE_GB_MOVIE;
-  const sizeGB = getSizeInGB(stream);
   if (sizeGB !== null && sizeGB > maxSize) return false;
-  
+
   return true;
 }
 
+function sortAndGroup(streams, type) {
+  const filtered = streams.filter(s => filterStream(s, type));
+
+  // Deduplicate by infoHash then by title+size fingerprint
+  const seen = new Set();
+  const unique = filtered.filter(s => {
+    const key = s.infoHash
+      ? s.infoHash.toLowerCase()
+      : `${(s.title || '').trim().toLowerCase()}::${getSizeGB(s)}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+
+  // Group by quality bucket
+  const byQuality = {};
+  unique.forEach(s => {
+    const q = getQuality(s.title);
+    if (!byQuality[q]) byQuality[q] = [];
+    byQuality[q].push(s);
+  });
+
+  // Within each bucket: priority source order, then seeders desc
+  for (const q in byQuality) {
+    byQuality[q].sort((a, b) => {
+      const srcA = detectSource(a.title);
+      const srcB = detectSource(b.title);
+      const ordA = srcA ? srcA.order : 999;
+      const ordB = srcB ? srcB.order : 999;
+      if (ordA !== ordB) return ordA - ordB;
+      return getSeeders(b) - getSeeders(a);
+    });
+  }
+
+  // Flatten: best quality first, capped at LINKS_PER_QUALITY per bucket
+  const sortedQualities = Object.keys(byQuality).sort(
+    (a, b) => (QUALITY_RANK[a] || 999) - (QUALITY_RANK[b] || 999)
+  );
+
+  const result = [];
+  sortedQualities.forEach(q => {
+    result.push(...byQuality[q].slice(0, LINKS_PER_QUALITY));
+  });
+
+  return result;
+}
+
+// ─── TITLE BUILDER ─────────────────────────────────────────────────────────────
+
+function formatBytes(gb) {
+  if (gb === null) return null;
+  return gb >= 1 ? `${gb.toFixed(2)} GB` : `${(gb * 1024).toFixed(0)} MB`;
+}
+
+function extractMovieName(title = '') {
+  return title
+    .replace(/\b(4k|2160p|1080p?|720p?|576p|480p?|360p?|240p?)\b.*/i, '')
+    .replace(/\b(bluray|webrip|webdl|web-dl|hdtv|dvdrip)\b.*/i, '')
+    .replace(/[\.\-_]+/g, ' ')
+    .replace(/\s*\(\d{4}\)\s*$/, '')
+    .trim();
+}
+
+function extractYear(title = '') {
+  const m = title.match(/\b(19\d{2}|20\d{2})\b/);
+  return m ? m[1] : '';
+}
+
+function getAudio(title = '') {
+  if (/DDP?\s*Atmos/i.test(title)) return 'Atmos';
+  if (/DDP|EAC3/i.test(title))     return 'DD+';
+  if (/DTS[-\s]?HD/i.test(title))  return 'DTS-HD';
+  if (/DTS/i.test(title))          return 'DTS';
+  if (/TrueHD/i.test(title))       return 'TrueHD';
+  if (/AAC/i.test(title))          return 'AAC';
+  if (/AC3|Dolby/i.test(title))    return 'DD';
+  return '';
+}
+
+function getLanguages(title = '') {
+  const map = {
+    english: 'EN', french: 'FR', spanish: 'ES', german: 'DE',
+    italian: 'IT', portuguese: 'PT', russian: 'RU', japanese: 'JA',
+    korean: 'KO', chinese: 'ZH', hindi: 'HI', arabic: 'AR',
+  };
+  const lower = title.toLowerCase();
+  return Object.entries(map).filter(([k]) => lower.includes(k)).map(([, v]) => v);
+}
+
+function buildTitle(stream) {
+  const raw  = stream._rawTitle || stream.title || '';
+  const name = extractMovieName(raw);
+  const year = extractYear(raw);
+  const disp = year ? `${name} (${year})` : name;
+
+  const seeders  = getSeeders(stream);
+  const sizeGB   = getSizeGB(stream);
+  const src      = detectSource(raw);
+  const srcLabel = src ? src.display : 'Unknown';
+  const audio    = getAudio(raw);
+  const langs    = getLanguages(raw);
+
+  const lines = [
+    `🔆 ${disp}`,
+    `🌱 ${seeders}`,
+    sizeGB !== null ? `💾 ${formatBytes(sizeGB)}` : '⚠️ Size unknown',
+    `🏅 ${srcLabel}`,
+  ];
+
+  let l5 = '';
+  if (langs.length) l5 += `🇬🇧 ${langs.join(' • ')}`;
+  if (audio)        l5 += (l5 ? '  ' : '') + `🔊 ${audio}`;
+  if (l5) lines.push(l5);
+
+  return lines.join('\n');
+}
+
+// ─── UPSTREAM FETCH ────────────────────────────────────────────────────────────
+
 async function fetchUpstream(type, id) {
-  for (const baseUrl of UPSTREAM_URLS) {
+  for (const base of UPSTREAM_URLS) {
     try {
       const controller = new AbortController();
-      const timeout = setTimeout(() => controller.abort(), 8000);
-      const res = await fetch(`${baseUrl}/stream/${type}/${id}.json`, { signal: controller.signal });
-      clearTimeout(timeout);
+      const timer      = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+      const url        = `${base}/stream/${type}/${id}.json`;
+      const res        = await fetch(url, { signal: controller.signal });
+      clearTimeout(timer);
       if (res.ok) {
         const data = await res.json();
-        if (data.streams?.length) return data.streams;
+        if (data.streams?.length) {
+          console.log(`[upstream] ${data.streams.length} streams from ${url}`);
+          return data.streams;
+        }
       }
-    } catch (e) {}
+    } catch (e) {
+      console.warn(`[upstream] failed: ${e.message}`);
+    }
   }
   return [];
 }
 
-function sortAndGroup(streams, type = 'movie') {
-  const filtered = streams.filter(s => filterStream(s, type));
-  
-  const byQuality = {};
-  filtered.forEach(stream => {
-    const quality = getQuality(stream.title);
-    if (!byQuality[quality]) byQuality[quality] = [];
-    byQuality[quality].push(stream);
-  });
-  
-  for (const quality in byQuality) {
-    byQuality[quality].sort((a, b) => {
-      const sourceA = detectSource(a.title);
-      const sourceB = detectSource(b.title);
-      const orderA = getSourceOrder(sourceA);
-      const orderB = getSourceOrder(sourceB);
-      if (orderA !== orderB) return orderA - orderB;
-      return getSeeders(b) - getSeeders(a);
-    });
+async function fetchSubtitles(type, id) {
+  try {
+    const controller = new AbortController();
+    const timer      = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    const url        = `${SUBTITLES_URL}/subtitles/${type}/${id}.json`;
+    const res        = await fetch(url, { signal: controller.signal });
+    clearTimeout(timer);
+    if (res.ok) {
+      const data = await res.json();
+      return data.subtitles || [];
+    }
+  } catch (e) {
+    console.warn(`[subtitles] failed: ${e.message}`);
   }
-  
-  const result = [];
-  const sortedQualities = Object.keys(byQuality).sort((a, b) => {
-    const rankA = QUALITY_RANK[a] || 999;
-    const rankB = QUALITY_RANK[b] || 999;
-    return rankA - rankB;
-  });
-  
-  sortedQualities.forEach(quality => {
-    const topLinks = byQuality[quality].slice(0, LINKS_PER_QUALITY);
-    result.push(...topLinks);
-  });
-  
-  return result;
+  return [];
 }
 
+// ─── ROUTES ────────────────────────────────────────────────────────────────────
+
 app.get('/manifest.json', (req, res) => {
   res.json({
-    id: 'org.ghostream.platinum',
-    name: 'Ghostream 🚀',
-    description: 'Stream Everything You Want\nMade With 🤍 By Van',
-    version: '7.3.0',
-    resources: ['stream'],
-    types: ['movie', 'series'],
-    idPrefixes: ['tt'],
-    catalogs: []
+    id:          'community.ghostreamplus',
+    name:        'Ghostream+ 🎬',
+    description: 'Stream Everything you want\nYTS · Knaben\nMade with 🤍 by Van',
+    version:     '7.0.5',
+    logo:        'https://i.imgur.com/wEYbVqL.png',
+    resources:   ['stream', 'subtitles'],
+    types:       ['movie', 'series'],
+    idPrefixes:  ['tt'],
+    catalogs:    [],
   });
 });
 
 app.get('/stream/:type/:id.json', async (req, res) => {
   const { type, id } = req.params;
   try {
-    const streams = await fetchUpstream(type, id);
-    const sorted = sortAndGroup(streams, type);
-    res.json({ streams: sorted });
+    const raw     = await fetchUpstream(type, id);
+    const sorted  = sortAndGroup(raw, type);
+
+    // Apply unified display title
+    const titled = sorted.map(s => {
+      const clone      = Object.assign({}, s);
+      clone._rawTitle  = s.title || s.name || '';
+      clone.title      = buildTitle(clone);
+      return clone;
+    });
+
+    console.log(`[handler] ${type}/${id} → ${titled.length} final streams`);
+    res.json({ streams: titled });
   } catch (e) {
+    console.error('[handler] error:', e);
     res.json({ streams: [] });
   }
 });
 
+app.get('/subtitles/:type/:id.json', async (req, res) => {
+  const { type, id } = req.params;
+  try {
+    const subs = await fetchSubtitles(type, id);
+    res.json({ subtitles: subs });
+  } catch (e) {
+    res.json({ subtitles: [] });
+  }
+});
+
+// Debug: raw upstream response before any filtering
 app.get('/debug/:type/:id.json', async (req, res) => {
   const { type, id } = req.params;
   try {
     const streams = await fetchUpstream(type, id);
-    res.json({ streams });
+    res.json({ count: streams.length, streams });
   } catch (e) {
     res.status(500).json({ error: e.message });
   }
 });
 
-app.listen(PORT, () => console.log(`Ghostream 🚀 on ${PORT}`));
+// ─── START ─────────────────────────────────────────────────────────────────────
+
+app.listen(PORT, () => console.log(`Ghostream+ 🎬 running on http://0.0.0.0:${PORT}`));