Update index.js

index.js

@@ -1,121 +1,202 @@
 const express = require('express');
-const axios = require('axios');
-const app = express();
+const fetch = require('node-fetch');
 
+const app = express();
 const PORT = process.env.PORT || 7860;
 
-// Quality order: highest first
-const QUALITY_ORDER = [
-  '1080p', '720p', '576p', '480p', '360p', '240p',
-  '1080', '720', '480', '360',
-  'hdrip', 'webrip', 'brrip', 'hdtv', 'bluray', 'dvdrip',
+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 UPSTREAM_URLS = [
+  'https://torrentio.strem.fun',
+  'https://torrentio.stremio.my.id'
 ];
 
-// Quality keywords to exclude (4K, screener, CAM, 3D)
-const EXCLUDE_KEYWORDS = ['4k', '2160p', 'screenr', 'screener', 'cam', '3d'];
+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 }
+];
+
+const QUALITY_RANK = {
+  '1080p': 1,
+  '720p': 2,
+  'webdl': 3,
+  'webrip': 4,
+  '576p': 5,
+  '480p': 6,
+  'bluray': 7
+};
 
-// Maximum 5 torrent links per quality tier
 const LINKS_PER_QUALITY = 5;
 
-// Extract quality from stream title
-function extractQuality(title) {
-  const match = title.match(/\b(\d{3,4}p)\b/i);
-  if (match) return match[1].toLowerCase();
+function getQuality(title = '') {
   const lower = title.toLowerCase();
-  return QUALITY_ORDER.find(q => lower.includes(q)) || 'other';
+  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;
 }
 
-// Sort quality: higher = earlier in list
-function qualitySortKey(quality) {
-  const idx = QUALITY_ORDER.indexOf(quality);
-  return idx !== -1 ? idx : QUALITY_ORDER.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;
 }
 
-// Filter blacklisted qualities, group by quality, limit per quality, sort
-function filterAndArrange(streams) {
-  // Remove blacklisted qualities
-  const filtered = streams.filter(s => {
-    const title = (s.title || s.name || '').toLowerCase();
-    return !EXCLUDE_KEYWORDS.some(kw => title.includes(kw));
-  });
+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;
+}
 
-  // Group streams by quality
-  const groups = {};
-  for (const s of filtered) {
-    const q = extractQuality(s.title || s.name || '');
-    if (!groups[q]) groups[q] = [];
-    groups[q].push(s);
+function detectSource(title = '') {
+  const lower = title.toLowerCase();
+  for (const src of SOURCE_CONFIG) {
+    if (lower.includes(src.name)) return src.name;
   }
+  return null;
+}
 
-  // Limit to 5 per quality and flatten
-  const result = [];
-  for (const [q, items] of Object.entries(groups)) {
-    result.push(...items.slice(0, LINKS_PER_QUALITY));
+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) {}
   }
+  return [];
+}
 
-  // Sort from highest quality to lowest
-  result.sort((a, b) => {
-    const qA = extractQuality(a.title || a.name || '');
-    const qB = extractQuality(b.title || b.name || '');
-    return qualitySortKey(qA) - qualitySortKey(qB);
+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;
 }
 
-// Serve manifest.json
 app.get('/manifest.json', (req, res) => {
   res.json({
-    id: 'org.filterproxy.streams',
-    name: 'Filter Proxy',
-    description: 'Merges Torrentio + TPB+, filters by size and quality, sorts 1080p→lower, excludes 4K/CAM/3D',
-    version: '1.0.0',
+    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: [],
+    catalogs: []
   });
 });
 
-// Handle stream requests
 app.get('/stream/:type/:id.json', async (req, res) => {
   const { type, id } = req.params;
-  const queryString = req.url.split('?')[1] || '';
-
   try {
-    // Fetch from both upstream addons with Torrentio size limits applied
-    const results = await Promise.allSettled([
-      axios.get(
-        `https://torrentio.strem.fun/stream/${type}/${id}.json?${queryString}&maxSize=4GB,1.5GB`,
-        { timeout: 15000 }
-      ),
-      axios.get(
-        `https://thepiratebay-plus.strem.fun/stream/${type}/${id}.json?${queryString}`,
-        { timeout: 15000 }
-      ),
-    ]);
-
-    // Merge all streams
-    let allStreams = [];
-    for (const r of results) {
-      if (r.status === 'fulfilled' && r.value.data?.streams) {
-        allStreams = allStreams.concat(r.value.data.streams);
-      }
-    }
-
-    // Apply filtering and sorting
-    const finalStreams = filterAndArrange(allStreams);
-    res.json({ streams: finalStreams });
-  } catch (err) {
-    res.status(500).json({ error: 'Failed to fetch streams' });
+    const streams = await fetchUpstream(type, id);
+    const sorted = sortAndGroup(streams, type);
+    res.json({ streams: sorted });
+  } catch (e) {
+    res.json({ streams: [] });
   }
 });
 
-// Health check
-app.get('/', (req, res) => {
-  res.send('Filter Proxy Running. Add /manifest.json to Stremio.');
+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 });
+  }
 });
 
-app.listen(PORT, '0.0.0.0', () => {
-  console.log(`Filter proxy running on port ${PORT}`);
-});
+app.listen(PORT, () => console.log(`Ghostream 🚀 on ${PORT}`));