Update index.js

index.js

@@ -1,304 +1,202 @@
 const express = require('express');
 const fetch = require('node-fetch');
+
 const app = express();
 const PORT = process.env.PORT || 7860;
 
-// ─── CORS ────────────────────────────────────────────────────────────────────
 app.use((req, res, next) => {
-  res.setHeader('Access-Control-Allow-Origin', '*');
-  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+  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();
 });
 
-// ═══════════════════════════════════════════════════════════════════════════════
-// KEYS — Replace OS_API_KEY with your free key from opensubtitles.com
-// ═══════════════════════════════════════════════════════════════════════════════
-const SUBDL_KEY   = 'subdl_2o2IC1-F6J1ru2YgeX6cP-I08DdL4VO0TJJqRLLcfAk';
-const OS_API_KEY  = 'FJqHyO18FxNEVdGQEPJ1hEM4tc6RqIZF';
-const OS_APP_NAME = 'VanSubs';   // your app name for the User-Agent header
-const OS_BASE     = 'https://api.opensubtitles.com/api/v1';
-
-// ─── MANIFEST ────────────────────────────────────────────────────────────────
-app.get('/', (req, res) => res.send('Van Subs Engine v7 ✅ Online'));
-
-app.get('/manifest.json', (req, res) => res.json({
-  id:          'org.van.humansubtitles',
-  name:        'Van Subs 🎬',
-  description: 'Human-Verified Arabic & English. Anti-AI. Hash-Precision Sync.',
-  version:     '7.0.0',
-  resources:   ['subtitles'],
-  types:       ['movie', 'series'],
-  idPrefixes:  ['tt'],
-  catalogs:    []
-}));
-
-// ─── ROUTES ──────────────────────────────────────────────────────────────────
-app.get('/subtitles/:type/:id.json',        (req, res) => handleRequest(req, res));
-app.get('/subtitles/:type/:id/:extra.json', (req, res) => handleRequest(req, res));
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// PILLAR 1 — PURITY
-// ═══════════════════════════════════════════════════════════════════════════════
-const AI_FLAGS = [
-  'ai-translated','machine translation','chatgpt','translated from',
-  'auto-translated','google translate','deepl','whisper','ai generated',
-  'machine-translated','openai','gpt-4','gpt4','auto translate'
+const UPSTREAM_URLS = [
+  'https://torrentio.strem.fun',
+  'https://torrentio.stremio.my.id'
 ];
 
-// Hard language contamination — kills Spanish/French bleeding into English slot
-const LANG_POISON = [
-  'spanish','español','espanol','latino','castellano',
-  'french','français','francais','portuguese','português',
-  'german','deutsch','italian','italiano','turkish',
-  '.es.','_es_','.spa.','_spa_','[spa]','[es]',
-  '.fr.','_fr_','.por.','_por_'
+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 isHuman(filename) {
-  const n = (filename || '').toLowerCase();
-  return !AI_FLAGS.some(f => n.includes(f));
-}
-
-function isCleanLang(filename, lang) {
-  if (lang === 'Arabic') return true;
-  const n = (filename || '').toLowerCase();
-  return !LANG_POISON.some(p => n.includes(p));
+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;
 }
 
-// ═══════════════════════════════════════════════════════════════════════════════
-// PILLAR 3 — ALIGNMENT: Compound Heuristic Scoring
-// Scene group + resolution compound bonus ensures perfect encode match at Index 0
-// ═══════════════════════════════════════════════════════════════════════════════
-const TIER1 = ['qxr','psa','galaxyrg','ntb','deflate','epsilon','tigole','framestor'];
-const TIER2 = ['yts','yify','rarbg','fgt','amzn','flux','cm','evolve','tepes'];
-const TIER3 = ['bluray','blu-ray','webdl','web-dl','webrip','web-rip','dvdrip','hdrip'];
-const AUDIO = ['truehd.atmos','truehd','atmos','ddp5.1','ddp5','ddp','dts-hd','dts','ac3','aac'];
-
-function score(filename) {
-  if (!filename) return 0;
-  const n = filename.toLowerCase();
-  let groupScore = 0, groupHit = false;
-
-  TIER1.forEach((g, i) => { if (n.includes(g)) { groupScore = (TIER1.length - i) * 20; groupHit = true; }});
-  if (!groupHit) TIER2.forEach((g, i) => { if (n.includes(g)) { groupScore = (TIER2.length - i) * 12; groupHit = true; }});
-  if (!groupHit) TIER3.forEach((g, i) => { if (n.includes(g)) { groupScore = (TIER3.length - i) * 6; groupHit = true; }});
-
-  let resScore = 0;
-  if (n.includes('2160p') || n.includes('4k'))  resScore = 25;
-  else if (n.includes('1080p') || n.includes('1080')) resScore = 18;
-  else if (n.includes('720p'))                        resScore = 10;
-
-  // Compound bonus — both group AND resolution present = multiplied weight
-  const compound = (groupHit && resScore > 0) ? Math.round((groupScore + resScore) * 0.6) : 0;
-
-  let audioScore = 0;
-  AUDIO.forEach((t, i) => { if (n.includes(t)) audioScore += (AUDIO.length - i) * 4; });
-
-  return groupScore + resScore + compound + audioScore;
+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;
 }
 
-// ═══════════════════════════════════════════════════════════════════════════════
-// EXTRA PARAM PARSER — Stremio passes videoHash & videoSize here
-// This is the key to hash-precision sync with OpenSubtitles
-// ═══════════════════════════════════════════════════════════════════════════════
-function parseExtra(raw) {
-  if (!raw) return {};
-  try {
-    const clean = decodeURIComponent((raw || '').replace('.json', ''));
-    return Object.fromEntries(clean.split('&').map(p => p.split('=')).filter(p => p.length === 2));
-  } catch { return {}; }
+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;
 }
 
-// ─── FETCH HELPERS ───────────────────────────────────────────────────────────
-async function timedFetch(url, opts = {}, ms = 9000) {
-  const ctrl = new AbortController();
-  const t = setTimeout(() => ctrl.abort(), ms);
-  try   { return await fetch(url, { ...opts, signal: ctrl.signal }); }
-  finally { clearTimeout(t); }
+function detectSource(title = '') {
+  const lower = title.toLowerCase();
+  for (const src of SOURCE_CONFIG) {
+    if (lower.includes(src.name)) return src.name;
+  }
+  return null;
 }
 
-async function safeJson(r, tag) {
-  const txt = await r.text();
-  try   { return JSON.parse(txt); }
-  catch { console.error(`[${tag}] bad JSON:`, txt.slice(0, 200)); return null; }
+function getSourceOrder(sourceName) {
+  const config = SOURCE_CONFIG.find(c => c.name === sourceName);
+  return config ? config.order : 999;
 }
 
-// ─── CORE HANDLER ────────────────────────────────────────────────────────────
-async function handleRequest(req, res) {
-  const { type } = req.params;
-  const rawId    = req.params.id.replace('.json', '');
-  const parts    = rawId.split(':');
-  const imdbId   = parts[0];
-  const season   = parts[1] ? parseInt(parts[1]) : null;
-  const episode  = parts[2] ? parseInt(parts[2]) : null;
-  const extra    = parseExtra(req.params.extra);
-  const hash     = extra.videoHash || null;
-  const size     = extra.videoSize || null;
-
-  console.log(`\n[VanSubs] ▶ ${type} ${imdbId} S${season ?? '-'}E${episode ?? '-'} hash=${hash ?? 'none'}`);
-
-  // Fire both providers simultaneously — neither waits for the other
-  const [r1, r2] = await Promise.allSettled([
-    fetchSubDL(imdbId, type, season, episode),
-    fetchOpenSubtitles(imdbId, type, season, episode, hash, size)
-  ]);
-
-  let pool = [];
-  if (r1.status === 'fulfilled') { console.log(`[SubDL] ${r1.value.length} raw`); pool.push(...r1.value); }
-  else console.error('[SubDL] FAILED:', r1.reason?.message);
-  if (r2.status === 'fulfilled') { console.log(`[OpenSubs] ${r2.value.length} raw`); pool.push(...r2.value); }
-  else console.error('[OpenSubs] FAILED:', r2.reason?.message);
-
-  // Sanitation pass — AI garbage + language contamination + invalid URLs
-  const clean = pool.filter(s =>
-    s.url && s.url.startsWith('http') &&
-    isHuman(s.filename) &&
-    isCleanLang(s.filename, s.lang)
-  );
-
-  // Hash-matched tracks get a massive score bonus — they are frame-perfect
-  // This guarantees hash matches always float to Index Zero
-  clean.forEach(s => {
-    if (s.hashMatch) s._score = 9999;
-    else             s._score = score(s.filename);
-  });
-
-  clean.sort((a, b) => b._score - a._score);
-
-  // Sweet spot: 3 per language
-  // Index 0 = perfect match (auto-selected by Stremio)
-  // Index 1-2 = fallbacks if encode differs
-  const TOP = 3;
-  const arabic  = clean.filter(s => s.lang === 'Arabic').slice(0, TOP);
-  const english = clean.filter(s => s.lang === 'English').slice(0, TOP);
-  const final   = [...arabic, ...english];
-
-  const subtitles = final.map((s, i) => ({
-    id:   `van_${imdbId}_${i}`,
-    url:  s.url,
-    lang: s.lang
-  }));
-
-  console.log(`[VanSubs] ✅ AR:${arabic.length} EN:${english.length}`);
-  console.log(`[VanSubs] #0 → "${final[0]?.filename ?? 'none'}" (score:${final[0]?._score ?? 0})`);
-  res.json({ subtitles });
+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;
 }
 
-// ═══════════════════════════════════════════════════════════════════════════════
-// PROVIDER 1 — SubDL
-// Best for: Arabic subtitles, scene release matching, new content
-// ═══════════════════════════════════════════════════════════════════════════════
-async function fetchSubDL(imdbId, type, season, episode) {
-  let url = `https://api.subdl.com/api/v1/subtitles`
-    + `?api_key=${SUBDL_KEY}`
-    + `&imdb_id=${imdbId}`
-    + `&languages=AR,EN`
-    + `&subs_per_page=30`
-    + `&releases=1`;
-
-  if (type === 'series' && season !== null && episode !== null)
-    url += `&season_number=${season}&episode_number=${episode}`;
-
-  const r    = await timedFetch(url);
-  const data = await safeJson(r, 'SubDL');
-  if (!data?.status) { console.error('[SubDL] err:', data?.error); return []; }
-
-  return (data.subtitles || []).map(sub => {
-    const lang = (sub.language || '').toLowerCase().startsWith('ar') ? 'Arabic' : 'English';
-    let   dlUrl = sub.url || '';
-    if (dlUrl && !dlUrl.startsWith('http')) dlUrl = 'https://dl.subdl.com' + dlUrl;
-    return { filename: sub.release_name || sub.name || 'SubDL', url: dlUrl, lang };
-  }).filter(s => s.url);
+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) {}
+  }
+  return [];
 }
 
-// ═══════════════════════════════════════════════════════════════════════════════
-// PROVIDER 2 — OpenSubtitles REST v3
-// Best for: Hash-precision English sync, massive archive, bulletproof stability
-//
-// Two-step flow:
-//   Step 1: GET /subtitles — search by IMDB ID + optional hash → get file_id list
-//   Step 2: POST /download  — exchange file_id for direct download URL
-//
-// Hash mode: when videoHash is available, OS matches the EXACT file
-// the user is playing — this is frame-perfect sync, eliminates all drift
-// ═══════════════════════════════════════════════════════════════════════════════
-async function fetchOpenSubtitles(imdbId, type, season, episode, videoHash, videoSize) {
-  const headers = {
-    'Api-Key':      OS_API_KEY,
-    'Content-Type': 'application/json',
-    'User-Agent':   `${OS_APP_NAME} v7.0`
-  };
-
-  // ── Step 1: Search ───────────────────────────────────────────────────────
-  const imdbNumeric = imdbId.replace('tt', '');
-  let searchUrl = `${OS_BASE}/subtitles`
-    + `?imdb_id=${imdbNumeric}`
-    + `&languages=en,ar`
-    + `&order_by=download_count`
-    + `&order_direction=desc`
-    + `&per_page=20`;
-
-  if (type === 'series' && season !== null && episode !== null) {
-    searchUrl += `&season_number=${season}&episode_number=${episode}`;
+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;
+  });
+  
+  sortedQualities.forEach(quality => {
+    const topLinks = byQuality[quality].slice(0, LINKS_PER_QUALITY);
+    result.push(...topLinks);
+  });
+  
+  return result;
+}
 
-  // Hash mode — when available, overrides everything for perfect match
-  if (videoHash) {
-    searchUrl += `&moviehash=${videoHash}`;
-    if (videoSize) searchUrl += `&moviebytesize=${videoSize}`;
-  }
+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: []
+  });
+});
 
-  const sr    = await timedFetch(searchUrl, { headers });
-  const sData = await safeJson(sr, 'OS/search');
-  if (!sData?.data?.length) {
-    console.log('[OpenSubs] no results for', imdbId);
-    return [];
+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 });
+  } catch (e) {
+    res.json({ streams: [] });
   }
+});
 
-  // ── Step 2: Get download URLs ────────────────────────────────────────────
-  // OS returns file_id per subtitle file — we POST to /download to get the URL
-  // We only resolve top 6 by download count (already ordered by API)
-  const candidates = sData.data.slice(0, 6);
-  const results    = [];
-
-  for (const item of candidates) {
-    try {
-      const attr   = item.attributes || {};
-      const files  = attr.files || [];
-      if (!files.length) continue;
-
-      const fileId  = files[0].file_id;
-      const langRaw = (attr.language || '').toLowerCase();
-      const lang    = langRaw === 'ar' || langRaw === 'arabic' ? 'Arabic' : 'English';
-      const fname   = files[0].file_name || attr.release || 'OpenSubtitles';
-
-      // Check if this is a hash-matched result — gives it perfect score
-      const isHashMatch = attr.moviehash_match === true;
-
-      const dlR    = await timedFetch(`${OS_BASE}/download`, {
-        method:  'POST',
-        headers,
-        body:    JSON.stringify({ file_id: fileId })
-      });
-      const dlData = await safeJson(dlR, 'OS/download');
-      if (!dlData?.link) continue;
-
-      results.push({
-        filename:  fname,
-        url:       dlData.link,
-        lang,
-        hashMatch: isHashMatch
-      });
-    } catch (e) {
-      console.error('[OpenSubs] download err:', e.message);
-    }
+app.get('/debug/:type/:id.json', async (req, res) => {
+  const { type, id } = req.params;
+  try {
+    const streams = await fetchUpstream(type, id);
+    res.json({ streams });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
   }
+});
 
-  console.log(`[OpenSubs] resolved ${results.length} download links`);
-  return results;
-}
-
-// ─── START ───────────────────────────────────────────────────────────────────
-app.listen(PORT, '0.0.0.0', () => console.log(`Van Subs v7 running on port ${PORT}`));
+app.listen(PORT, () => console.log(`Ghostream 🚀 on ${PORT}`));