Update index.js

index.js

@@ -1,371 +1,202 @@
 const express = require('express');
-const axios = require('axios');
+const fetch = require('node-fetch');
+
 const app = express();
 const PORT = process.env.PORT || 7860;
 
-const MAX_MOVIE_SIZE_GB = 4;
-const MAX_SERIES_SIZE_GB = 1.5;
-const PER_SOURCE_LIMIT = 3;
-const MIN_SEEDERS = 2;
-const BLOCK_SIZELESS = true;
+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 QUALITY_ORDER = [
-  '1080p', '720p', '576p', '480p', '360p', '240p',
-  '1080', '720', '480', '360',
-  'webdl', 'webrip', 'bluray'
+const UPSTREAM_URLS = [
+  'https://torrentio.strem.fun',
+  'https://torrentio.stremio.my.id'
 ];
-const EXCLUDE_KEYWORDS = ['4k', '2160p', 'screenr', 'screener', 'cam', '3d'];
-const PRIORITY_PROVIDERS = ['yts', 'eztv', 'nyasi'];
-const BLOCKED_PROVIDERS = [
-  '1337x', 'kickasstorrents', 'torrentgalaxy', 'magnetdl', 'horriblesubs',
-  'tokyotosho', 'anidex', 'rutor', 'rutracker',
-  'comando', 'bludv', 'micoleaodublado',
-  'torrent9', 'ilcorsaronero',
-  'mejortorrent', 'wolfmax4k', 'cinecalidad', 'besttorrents',
-];
-
-const SUBTITLES_URL = 'https://subsource.strem.top/c2tfOWEyOGJiMGI0ODdiY2UzYzlkOTA4Y2YzNmM5MGI2MWQxNjA0ZmI3ODBhZTQxMmMyYThiNzFhZDQ2MzZhMmQyYS9hcmFiaWMsZW5nbGlzaC9oaUluY2x1ZGUvdHlwZToxLDIsNC8';
 
-function extractQuality(t) {
-  const m = t.match(/\b(\d{3,4}p)\b/i);
-  if (m) return m[1].toLowerCase();
-  const l = t.toLowerCase();
-  return QUALITY_ORDER.find(q => l.includes(q)) || 'other';
-}
-
-function qualitySortKey(q) {
-  const i = QUALITY_ORDER.indexOf(q);
-  return i >= 0 ? i : QUALITY_ORDER.length;
-}
+const MIN_SEEDERS = 1;
+const ALLOWED_QUALITIES = ['480p', '576p', '720p', '1080p', 'webrip', 'webdl', 'bluray'];
+const MAX_SIZE_GB_MOVIE = 4;
+const MAX_SIZE_GB_SERIES = 1.5;
+
+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 }
+];
 
-function detectProvider(t) {
-  const m = t.match(/\[([^\]]+)\]/);
-  return m ? m[1].toLowerCase() : 'other';
+const QUALITY_RANK = {
+  '1080p': 1,
+  '720p': 2,
+  'webdl': 3,
+  'webrip': 4,
+  '576p': 5,
+  '480p': 6,
+  'bluray': 7
+};
+
+const LINKS_PER_QUALITY = 5;
+
+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';
+  return null;
 }
 
-function providerSortKey(p) {
-  const i = PRIORITY_PROVIDERS.indexOf(p);
-  return i >= 0 ? i : PRIORITY_PROVIDERS.length;
+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;
 }
 
-// Ultra‑strict size parser – only returns a value if it finds a true file size
-function parseSizeGB(t, obj) {
-  // First, look for explicitly labelled sizes (with emoji or "Size:")
-  if (t) {
-    const labeled = t.match(/(?:💾|📦|Size:|size:)\s*([\d.]+)\s*(GB|MB|TB)/i);
-    if (labeled) {
-      const v = parseFloat(labeled[1]), u = labeled[2].toUpperCase();
-      if (u === 'TB') return v * 1024;
-      if (u === 'GB') return v;
-      if (u === 'MB') return v / 1024;
-    }
-  }
-  // If the object has a separate 'size' field, use it
-  if (obj && obj.size) {
-    const m = String(obj.size).match(/^([\d.]+)\s*(GB|MB|TB)$/i);
-    if (m) {
-      const v = parseFloat(m[1]), u = m[2].toUpperCase();
-      if (u === 'TB') return v * 1024;
-      if (u === 'GB') return v;
-      if (u === 'MB') return v / 1024;
-    }
-  }
-  // If the object has a description with a size, use it
-  if (obj && obj.description) {
-    const descMatch = String(obj.description).match(/\b([\d.]+)\s*(GB|MB|TB)\b/i);
-    if (descMatch) {
-      const v = parseFloat(descMatch[1]), u = descMatch[2].toUpperCase();
-      if (u === 'TB') return v * 1024;
-      if (u === 'GB') return v;
-      if (u === 'MB') return v / 1024;
-    }
-  }
-  // No size found anywhere – return null
+function getSizeInGB(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;
 }
 
-// Same ultra‑strict logic for bytes
-function parseSizeBytes(t, obj) {
-  if (t) {
-    const labeled = t.match(/(?:💾|📦|Size:|size:)\s*([\d.]+)\s*(GB|MB|TB)/i);
-    if (labeled) {
-      const v = parseFloat(labeled[1]), u = labeled[2].toUpperCase();
-      if (u === 'TB') return v * 1024 * 1024 * 1024 * 1024;
-      if (u === 'GB') return v * 1024 * 1024 * 1024;
-      if (u === 'MB') return v * 1024 * 1024;
-    }
-  }
-  if (obj && obj.size) {
-    const m = String(obj.size).match(/^([\d.]+)\s*(GB|MB|TB)$/i);
-    if (m) {
-      const v = parseFloat(m[1]), u = m[2].toUpperCase();
-      if (u === 'TB') return v * 1024 * 1024 * 1024 * 1024;
-      if (u === 'GB') return v * 1024 * 1024 * 1024;
-      if (u === 'MB') return v * 1024 * 1024;
-    }
-  }
-  if (obj && obj.description) {
-    const descMatch = String(obj.description).match(/\b([\d.]+)\s*(GB|MB|TB)\b/i);
-    if (descMatch) {
-      const v = parseFloat(descMatch[1]), u = descMatch[2].toUpperCase();
-      if (u === 'TB') return v * 1024 * 1024 * 1024 * 1024;
-      if (u === 'GB') return v * 1024 * 1024 * 1024;
-      if (u === 'MB') return v * 1024 * 1024;
-    }
+function detectSource(title = '') {
+  const lower = title.toLowerCase();
+  for (const src of SOURCE_CONFIG) {
+    if (lower.includes(src.name)) return src.name;
   }
   return null;
 }
 
-function isProviderBlocked(t) {
-  const p = detectProvider(t);
-  if (BLOCKED_PROVIDERS.includes(p)) return true;
-  const l = t.toLowerCase();
-  return BLOCKED_PROVIDERS.some(b => l.includes(b));
-}
-
-function formatBytes(b) {
-  if (!b) return '';
-  const g = b / (1024 * 1024 * 1024);
-  if (g >= 1) return g.toFixed(1) + ' GB';
-  const m = b / (1024 * 1024);
-  return m.toFixed(0) + ' MB';
+function getSourceOrder(sourceName) {
+  const config = SOURCE_CONFIG.find(c => c.name === sourceName);
+  return config ? config.order : 999;
 }
 
-function extractMovieName(t) {
-  const firstLine = t.split('\n')[0].trim();
-  const splitTokens = /[\s.]+(?:1080p|720p|480p|2160p|1440p|4K|WEBRip|WebDL|BluRay|BRRip|HDRip|HDTV|DVDRip|AMZN|WEB-DL|x265|x264|HEVC|AAC|AC3|EAC3|DDP|DDP5|5\.1|2\.0|H264|10bit|S\d{2}|COMPLETE|LiNE|Rapta|YTS|YIFY|RARBG|ETRG|EVO|GalaxyRG|Tigole|UTR|RMTeam|ION10|MeGusta|Vyndros|FLUX|TiPEX|eztv|EZTV)\b/i;
-  const parts = firstLine.split(splitTokens);
-  let name = parts[0].replace(/\./g, ' ').replace(/\s+/g, ' ').trim();
-  name = name.replace(/\s+\b(19|20)\d{2}\b$/, '').trim();
-  return name || 'Unknown';
+function filterStream(stream, type = 'movie') {
+  const title = stream.title || '';
+  if (!stream.url && !stream.infoHash) return false;
+  
+  const quality = getQuality(title);
+  if (!ALLOWED_QUALITIES.includes(quality)) return false;
+  
+  if (getSeeders(stream) < MIN_SEEDERS) return false;
+  
+  if (!detectSource(title)) 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 extractYear(t) {
-  const firstLine = t.split('\n')[0].trim();
-  const yearMatch = firstLine.match(/\b(19\d{2}|20\d{2})\b/);
-  return yearMatch ? yearMatch[1] : '';
-}
-
-function parseStreamInfo(s) {
-  const t = s.title || s.name || '';
-
-  let resolution = null;
-  const rm = t.match(/(2160p|1440p|1080p|720p|480p|360p)/i);
-  if (rm) resolution = rm[1];
-
-  let ripType = '';
-  const rp = ['webdl','web-dl','webrip','web-rip','bluray','blu-ray','brrip','bdrip','hdrip','hdtv','dvdrip','dvdscr','hdcam','ts','tc','cam'];
-  const lt = t.toLowerCase();
-  for (const p of rp) {
-    if (lt.includes(p)) {
-      switch (p) {
-        case 'webdl': case 'web-dl': ripType = 'WebDL'; break;
-        case 'webrip': case 'web-rip': ripType = 'WEBRip'; break;
-        case 'bluray': case 'blu-ray': ripType = 'BluRay'; break;
-        case 'brrip': case 'bdrip': ripType = 'BRRip'; break;
-        case 'hdrip': ripType = 'HDRip'; break;
-        case 'hdtv': ripType = 'HDTV'; break;
-        case 'dvdrip': ripType = 'DVDRip'; break;
-        default: ripType = p.toUpperCase();
+async function fetchUpstream(type, id) {
+  for (const baseUrl 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);
+      if (res.ok) {
+        const data = await res.json();
+        if (data.streams?.length) return data.streams;
       }
-      break;
-    }
+    } catch (e) {}
   }
-
-  let seeders = 0;
-  const sm = t.match(/👤\s*(\d+)/);
-  if (sm) seeders = parseInt(sm[1]);
-
-  let indexer = detectProvider(t);
-  if (indexer === 'other') {
-    const im = t.match(/⚙️\s*(\S+)/);
-    if (im) {
-      indexer = im[1];
-    } else if (s._source) {
-      indexer = s._source;
-    }
-  }
-
-  const sizeBytes = parseSizeBytes(t, s);
-
-  let languages = [];
-  if (s.languages && s.languages.length) {
-    languages = s.languages;
-  } else {
-    const lm = t.match(/🇬🇧\s*([\s\S]+?)(?:\n|$)/);
-    if (lm) languages = lm[1].split('•').map(l => l.trim());
-  }
-
-  let audioInfo = '';
-  if (s.audioTags && s.audioTags.length) {
-    audioInfo = s.audioTags.join(' • ');
-  } else {
-    const am = t.match(/(?:DDP|EAC3|AAC|AC3|MP3|FLAC|DTS|TrueHD)\s*\d?\.?\d?/gi);
-    if (am) audioInfo = am.join(' • ');
-  }
-
-  return { resolution, ripType, seeders, indexer, sizeBytes, languages, audioInfo };
+  return [];
 }
 
-function buildUnifiedTitle(s) {
-  const i = parseStreamInfo(s);
-  const originalTitle = s.title || s.name || '';
-  const movieName = extractMovieName(originalTitle);
-  const year = extractYear(originalTitle);
-  const displayName = year ? `${movieName} (${year})` : movieName;
-
-  const l1 = '🔆 ' + displayName;
-  const l2 = '🙋🏻‍♂️ ' + (i.seeders || '0');
-
-  let l3 = '';
-  if (i.sizeBytes) {
-    l3 = '💾 ' + formatBytes(i.sizeBytes);
-  } else {
-    l3 = '⚠️ Size unknown';
-  }
-
-  const displayIndexer = i.indexer && i.indexer !== 'other'
-    ? i.indexer.charAt(0).toUpperCase() + i.indexer.slice(1)
-    : 'Unknown';
-  const l4 = '🏅 ' + displayIndexer;
-
-  let l5 = '';
-  if (i.languages.length) l5 += '🇬🇧 ' + i.languages.join(' • ');
-  if (i.audioInfo) {
-    if (l5) l5 += '  ';
-    l5 += '🔊 ' + i.audioInfo;
-  }
-
-  const lines = [l1, l2];
-  if (l3) lines.push(l3);
-  lines.push(l4);
-  if (l5) lines.push(l5);
-
-  return lines.join('\n');
-}
-
-function filterAndArrange(streams, isSeries) {
-  const maxSize = isSeries ? MAX_SERIES_SIZE_GB : MAX_MOVIE_SIZE_GB;
-
-  const filtered = streams.filter(s => {
-    const t = s.title || s.name || '';
-    if (EXCLUDE_KEYWORDS.some(k => t.toLowerCase().includes(k))) return false;
-    if (isProviderBlocked(t)) return false;
-    const gb = parseSizeGB(t, s);
-    if (gb === null && BLOCK_SIZELESS) return false;
-    if (gb !== null && gb > maxSize) return false;
-    return true;
+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);
   });
-
-  const groups = {};
-  for (const s of filtered) {
-    const q = extractQuality(s.title || s.name || '');
-    (groups[q] ||= []).push(s);
-  }
-
+  
+  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);
+    });
+  }
+  
   const result = [];
-  for (const [q, items] of Object.entries(groups)) {
-    const buckets = {};
-    for (const s of items) {
-      const src = s._source;
-      (buckets[src] ||= []).push(s);
-    }
-    const picks = [];
-    for (const [src, bucket] of Object.entries(buckets)) {
-      bucket.sort((a, b) => {
-        const pa = detectProvider(a.title || a.name || '');
-        const pb = detectProvider(b.title || a.name || '');
-        return providerSortKey(pa) - providerSortKey(pb);
-      });
-      picks.push(...bucket.slice(0, PER_SOURCE_LIMIT));
-    }
-    result.push(...picks);
-  }
-
-  result.sort((a, b) => {
-    return qualitySortKey(extractQuality(a.title || a.name || '')) -
-           qualitySortKey(extractQuality(b.title || a.name || ''));
+  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;
 }
 
 app.get('/manifest.json', (req, res) => {
   res.json({
-    id: 'org.ghostream.plus',
-    name: 'Ghostream+ 🚀',
+    id: 'org.ghostream.platinum',
+    name: 'Ghostream 🚀',
     description: 'Stream Everything You Want\nMade With 🤍 By Van',
-    version: '5.0.6',
-    resources: ['stream', 'subtitles'],
+    version: '7.3.0',
+    resources: ['stream'],
     types: ['movie', 'series'],
     idPrefixes: ['tt'],
     catalogs: []
   });
 });
 
-app.get('/subtitles/:type/:id.json', async (req, res) => {
+app.get('/stream/:type/:id.json', async (req, res) => {
+  const { type, id } = req.params;
   try {
-    const response = await axios.get(`${SUBTITLES_URL}/subtitles/${req.params.type}/${req.params.id}.json`, { timeout: 15000 });
-    res.json(response.data);
+    const streams = await fetchUpstream(type, id);
+    const sorted = sortAndGroup(streams, type);
+    res.json({ streams: sorted });
   } catch (e) {
-    res.json({ subtitles: [] });
+    res.json({ streams: [] });
   }
 });
 
-app.get('/subtitles/:type/:id/:extra.json', async (req, res) => {
+app.get('/debug/:type/:id.json', async (req, res) => {
+  const { type, id } = req.params;
   try {
-    const response = await axios.get(`${SUBTITLES_URL}/subtitles/${req.params.type}/${req.params.id}/${req.params.extra}.json`, { timeout: 15000 });
-    res.json(response.data);
+    const streams = await fetchUpstream(type, id);
+    res.json({ streams });
   } catch (e) {
-    res.json({ subtitles: [] });
+    res.status(500).json({ error: e.message });
   }
 });
 
-app.get('/stream/:type/:id.json', async (req, res) => {
-  const { type, id } = req.params;
-  const qs = req.url.split('?')[1] || '';
-  const isSeries = (type === 'series');
-
-  const sources = [
-    { name: 'torrentio',  url: `https://torrentio.strem.fun/stream/${type}/${id}.json?${qs}&maxSize=4GB,1.5GB` }
-  ];
-
-  const results = await Promise.allSettled(
-    sources.map(src =>
-      axios.get(src.url, { timeout: 12000 })
-        .then(r => {
-          const streams = r.data.streams || [];
-          return streams.map(s => ({ ...s, _source: src.name }));
-        })
-        .catch(() => [])
-    )
-  );
-
-  let all = [];
-  results.forEach(r => {
-    if (r.status === 'fulfilled') all = all.concat(r.value);
-  });
-
-  const filtered = filterAndArrange(all, isSeries);
-  const unified = filtered.map(s => {
-    const info = parseStreamInfo(s);
-    let cleanName = '';
-    if (info.resolution) {
-      cleanName = info.resolution;
-      if (info.ripType) cleanName += ' ' + info.ripType;
-    } else if (info.ripType) {
-      cleanName = info.ripType;
-    } else {
-      cleanName = (s.title || s.name || '').split('\n')[0].trim();
-    }
-    return {
-      ...s,
-      name: cleanName,
-      title: buildUnifiedTitle(s)
-    };
-  });
-
-  res.json({ streams: unified });
-});
-
-app.listen(PORT, '0.0.0.0', () => {});
+app.listen(PORT, () => console.log(`Ghostream 🚀 on ${PORT}`));