Update index.js

index.js

@@ -1,58 +1,103 @@
 const express = require('express');
-const fetch = require('node-fetch');
-
+const fetch = require('node-fetch'); // Native dependency swap
 const app = express();
 const PORT = process.env.PORT || 7860;
 
+// --- CORS & STREMIO APP COMPATIBILITY HEADERS ---
 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();
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Headers', '*');
+    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    next();
 });
 
-const UPSTREAM_URLS = [
-  'https://torrentio.strem.fun',
-  'https://torrentio.stremio.my.id'
+// --- EXTRAS FOR SUBTITLE PIPELINE ---
+const STREAM_HISTORY_CACHE = new Map(); 
+
+// Private API Tokens wired natively
+const SUBDL_API_KEY = "subdl_2o2IC1-F6J1ru2YgeX6cP-I08DdL4VO0TJJqRLLcfAk"; 
+const SUBSOURCE_API_KEY = "sk_9a28bb0b487bce3c9d908cf36c90b61d1604fb780ae412c2a8b71ad4636a2d2a";
+// ------------------------------------
+
+const MAX_MOVIE_SIZE_GB = 4;
+const MAX_SERIES_SIZE_GB = 1.5;
+const PER_SOURCE_LIMIT = 999;
+const LINKS_PER_QUALITY = 2;
+const MIN_SEEDERS = 2;
+const BLOCK_SIZELESS = true;
+
+const QUALITY_ORDER = [
+  '1080p', '720p', '576p', '480p', '360p', '240p',
+  '1080', '720', '480', '360',
+  'webdl', 'webrip', 'bluray'
 ];
-
-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: 'rutracker', display: 'Rutracker', order: 8 }
+const EXCLUDE_KEYWORDS = ['4k', '2160p', 'screenr', 'screener', 'cam', '3d'];
+const PRIORITY_PROVIDERS = ['yts', 'eztv', 'nyasi'];
+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
-};
+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';
+}
 
-const LINKS_PER_QUALITY = 5;
+function qualitySortKey(q) {
+  const i = QUALITY_ORDER.indexOf(q);
+  return i >= 0 ? i : QUALITY_ORDER.length;
+}
 
-// ---------- Helper functions for unified title (from V2 layout) ----------
 function detectProvider(t) {
   const m = t.match(/\[([^\]]+)\]/);
-  return m ? m[1].toLowerCase() : 'other';
+  if (m) {
+    const baseMatch = m[1].toLowerCase().match(/^([a-z]+)/);
+    if (baseMatch) return baseMatch[1];
+  }
+  const ep = t.match(/⚙️\s*(\S+)/);
+  if (ep) return ep[1].toLowerCase();
+  return 'other';
+}
+
+function providerSortKey(p) {
+  const i = PRIORITY_PROVIDERS.indexOf(p);
+  return i >= 0 ? i : PRIORITY_PROVIDERS.length;
+}
+
+function parseSizeGB(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;
+      if (u === 'GB') return v;
+      if (u === 'MB') return v / 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;
+      if (u === 'GB') return v;
+      if (u === 'MB') return v / 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;
+      if (u === 'GB') return v;
+      if (u === 'MB') return v / 1024;
+    }
+  }
+  return null;
 }
 
 function parseSizeBytes(t, obj) {
@@ -86,6 +131,21 @@ function parseSizeBytes(t, obj) {
   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 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;
@@ -101,14 +161,6 @@ function extractYear(t) {
   return yearMatch ? yearMatch[1] : '';
 }
 
-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 parseStreamInfo(s) {
   const t = s.title || s.name || '';
 
@@ -140,14 +192,7 @@ function parseStreamInfo(s) {
   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;
-    }
-  }
+  if (indexer === 'other' && s._source) indexer = s._source;
 
   const sizeBytes = parseSizeBytes(t, s);
 
@@ -207,172 +252,243 @@ function buildUnifiedTitle(s) {
   return lines.join('\n');
 }
 
-// ---------- Original filtering functions (unchanged) ----------
-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 getSeeders(stream) {
-  if (stream.behaviorHints?.seeders) return stream.behaviorHints.seeders;
-  const match = stream.title?.match(/👤\s*(\d+)/);
-  return match ? parseInt(match[1], 10) : 0;
-}
-
-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;
-}
+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 detectSource(title = '') {
-  const lower = title.toLowerCase();
-  for (const src of SOURCE_CONFIG) {
-    if (lower.includes(src.name)) return src.name;
+  const groups = {};
+  for (const s of filtered) {
+    const q = extractQuality(s.title || s.name || '');
+    (groups[q] ||= []).push(s);
   }
-  return null;
-}
-
-function getSourceOrder(sourceName) {
-  const config = SOURCE_CONFIG.find(c => c.name === sourceName);
-  return config ? config.order : 999;
-}
-
-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;
-}
 
-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;
-      }
-    } catch (e) {}
+  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 || b.name || '');
+        const skA = providerSortKey(pa);
+        const skB = providerSortKey(pb);
+        if (skA !== skB) return skA - skB;
+        return pa.localeCompare(pb);
+      });
+      picks.push(...bucket.slice(0, LINKS_PER_QUALITY));
+    }
+    result.push(...picks);
   }
-  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);
-    });
-  }
-  
-  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;
+  result.sort((a, b) => {
+    return qualitySortKey(extractQuality(a.title || a.name || '')) -
+           qualitySortKey(extractQuality(b.title || b.name || ''));
   });
-  
-  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.platinum',
-    name: 'Ghostream 🚀',
-    description: 'Stream Everything You Want\nMade With 🤍 By Van',
-    version: '7.3.0',
-    resources: ['stream'],
+    id: 'org.ghostream.plus',
+    name: 'Ghostream+ 🚀',
+    description: 'Stream Everything You Want with Human Synced Subtitles\nMade With 🤍 By Van',
+    version: '8.0.0',
+    resources: ['stream', 'subtitles'],
     types: ['movie', 'series'],
     idPrefixes: ['tt'],
     catalogs: []
   });
 });
 
-app.get('/stream/:type/:id.json', async (req, res) => {
+// --- CORE UPGRADED CONTROLLERS ---
+
+app.get('/subtitles/:type/:id.json', async (req, res) => {
+  await handleSubtitleRequest(req, res);
+});
+
+app.get('/subtitles/:type/:id/:extra.json', async (req, res) => {
+  await handleSubtitleRequest(req, res);
+});
+
+async function handleSubtitleRequest(req, res) {
   const { type, id } = req.params;
+  let imdbId = id.split(':')[0];
+  
+  const metadata = STREAM_HISTORY_CACHE.get(imdbId) || { originalTitle: "" };
+  const targetReleaseGroup = extractReleaseGroupTag(metadata.originalTitle);
+
   try {
-    const streams = await fetchUpstream(type, id);
-    const sorted = sortAndGroup(streams, type);
-    // Apply the beautiful title template and clean short name
-    const formatted = sorted.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)
-      };
+    const [subDlRes, subsourceRes] = await Promise.allSettled([
+      fetchSubDL(id, type),
+      fetchSubsource(id, type)
+    ]);
+
+    let rawList = [];
+    if (subDlRes.status === 'fulfilled') rawList.push(...subDlRes.value);
+    if (subsourceRes.status === 'fulfilled') rawList.push(...subsourceRes.value);
+
+    const humanVerifiedSubs = rawList.filter(item => {
+      const name = (item.filename || "").toLowerCase();
+      return !name.includes("ai-translated") && !name.includes("machine translation") && !name.includes("chatgpt");
     });
-    res.json({ streams: formatted });
+
+    humanVerifiedSubs.sort((a, b) => {
+      const aMatch = targetReleaseGroup && a.filename.toLowerCase().includes(targetReleaseGroup.toLowerCase()) ? 1 : 0;
+      const bMatch = targetReleaseGroup && b.filename.toLowerCase().includes(targetReleaseGroup.toLowerCase()) ? 1 : 0;
+      return bMatch - aMatch; 
+    });
+
+    const output = humanVerifiedSubs.map((sub, index) => ({
+      id: `gh_sub_${index}`,
+      url: sub.downloadUrl,
+      lang: sub.langCode === 'ara' ? 'Arabic' : 'English'
+    }));
+
+    res.json({ subtitles: output });
+
+  } catch (err) {
+    res.json({ subtitles: [] });
+  }
+}
+
+function extractReleaseGroupTag(title) {
+  if (!title) return "";
+  const match = title.match(/\b(PSA|QxR|GalaxyRG|YTS|YIFY|RARBG|FGT|Erai-raws|MeGusta|Tigole)\b/i);
+  return match ? match[1] : "";
+}
+
+// Adapted to native node-fetch syntax
+async function fetchSubDL(stremioId, type) {
+  const parts = stremioId.split(':');
+  const imdbId = parts[0];
+  
+  let url = `https://api.subdl.com/v1/subtitles?api_key=${SUBDL_API_KEY}&imdb_id=${imdbId}&languages=eng,ara`;
+
+  if (type === 'series' && parts[1] && parts[2]) {
+    url += `&season=${parts[1]}&episode=${parts[2]}`;
+  }
+
+  try {
+    const res = await fetch(url, { timeout: 7000 });
+    const data = await res.json();
+    if (!data || !data.results) return [];
+
+    let items = [];
+    data.results.forEach(sub => {
+      const code = sub.lang === 'arabic' ? 'ara' : 'eng';
+      items.push({
+        filename: sub.filename || sub.release_name || "Subtitle Track",
+        downloadUrl: sub.url || sub.download_url,
+        langCode: code
+      });
+    });
+    return items;
   } catch (e) {
-    res.json({ streams: [] });
+    return [];
+  }
+}
+
+// Adapted to native node-fetch syntax
+async function fetchSubsource(stremioId, type) {
+  const parts = stremioId.split(':');
+  const imdbId = parts[0];
+
+  let url = `https://api.subsource.net/api/v1/subtitles/imdb/${imdbId}`;
+  if (type === 'series' && parts[1] && parts[2]) {
+    url += `?season=${parts[1]}&episode=${parts[2]}`;
   }
-});
 
-app.get('/debug/:type/:id.json', async (req, res) => {
-  const { type, id } = req.params;
   try {
-    const streams = await fetchUpstream(type, id);
-    res.json({ streams });
+    const res = await fetch(url, {
+      headers: { 'Authorization': `Bearer ${SUBSOURCE_API_KEY}` },
+      timeout: 7000
+    });
+    const data = await res.json();
+    if (!data || !data.subtitles) return [];
+
+    return data.subtitles
+      .filter(s => s.lang === 'english' || s.lang === 'arabic')
+      .map(s => ({
+        filename: s.release || s.filename || "Subsource Track",
+        downloadUrl: s.downloadUrl || s.url,
+        langCode: s.lang === 'arabic' ? 'ara' : 'eng'
+      }));
   } catch (e) {
-    res.status(500).json({ error: e.message });
+    return [];
+  }
+}
+
+// --- STREAM INTERCEPTOR ---
+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 imdbId = id.split(':')[0];
+
+  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 =>
+      fetch(src.url, { timeout: 12000 })
+        .then(async r => {
+          const data = await r.json();
+          const streams = 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);
+  
+  if (filtered.length > 0) {
+    STREAM_HISTORY_CACHE.set(imdbId, {
+      originalTitle: filtered[0].title || filtered[0].name || ""
+    });
   }
+
+  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, () => console.log(`Ghostream 🚀 on ${PORT}`));
+app.listen(PORT, '0.0.0.0', () => {
+  console.log(`Ghostream+ Engine deployed cleanly on port ${PORT}`);
+});