Update index.js

index.js

@@ -3,160 +3,578 @@
 const express = require('express');
 const axios   = require('axios');
 
-const app = express();
+const app  = express();
 const PORT = process.env.PORT || 7860;
 
-const UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36';
-
 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();
 });
 
-// SubsPlease
-async function scrapeSubsPlease(title) {
+const TMDB_KEY        = '83d364331c40bfbe29858aeed82f45cc';
+const UA              = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36';
+
+const MAX_SIZE_GB_MOVIE  = 4;
+const MAX_SIZE_GB_SERIES = 1.5;
+const LINKS_PER_QUALITY  = 5;
+const ALLOWED_QUALITIES  = ['4k', '1080p', '720p', '576p', '480p', 'webrip'];
+
+const QUALITY_RANK = {
+  '1080p': 1, '720p': 2, '576p': 3, '480p': 4,
+  '4k': 5, '2160p': 5, 'webrip': 6, 'webdl': 6,
+};
+
+const PRIORITY_PROVIDERS = ['subsplease', 'apibay', 'torrentcsv'];
+
+const ALLOWED_PROVIDERS = [
+  'subsplease',
+  'apibay',
+  'torrentcsv',
+  'thepiratebay',
+];
+
+const TR = [
+  'udp://tracker.opentrackr.org:1337/announce',
+  'udp://open.stealth.si:80/announce',
+  'udp://open.demonii.com:1337/announce',
+  'udp://tracker.torrent.eu.org:451/announce',
+  'udp://p4p.arenabg.com:1337/announce',
+  'udp://exodus.desync.com:6969/announce',
+  'udp://tracker.openbittorrent.com:6969/announce',
+  'udp://tracker.dler.org:6969/announce',
+  'https://tracker.moeblog.cn:443/announce',
+  'https://tracker.zhuqiy.com:443/announce',
+].map(t => '&tr=' + encodeURIComponent(t)).join('');
+
+function getQuality(str = '') {
+  const s = str.toLowerCase();
+  if (s.includes('4k') || s.includes('2160p') || s.includes('uhd')) return '4k';
+  if (s.includes('1080p'))  return '1080p';
+  if (s.includes('720p'))   return '720p';
+  if (s.includes('576p'))   return '576p';
+  if (s.includes('480p'))   return '480p';
+  if (s.includes('webrip')) return 'webrip';
+  if (s.includes('webdl') || s.includes('web-dl')) return 'webdl';
+  return null;
+}
+
+function getSizeGB(stream) {
+  const raw = stream.title || stream.name || '';
+  const m   = raw.match(/💾\s*([\d.]+)\s*(GB|MB)/i) || raw.match(/([\d.]+)\s*(GB|MB)/i);
+  if (!m) return null;
+  const val = parseFloat(m[1]);
+  return m[2].toUpperCase() === 'GB' ? val : val / 1024;
+}
+
+function getSeeders(stream) {
+  if (stream._seeders != null) return stream._seeders;
+  if (stream.behaviorHints?.seeders) return stream.behaviorHints.seeders;
+  const m = (stream.title || '').match(/👤\s*(\d+)/);
+  return m ? parseInt(m[1], 10) : 0;
+}
+
+function getLangLine(str = '') {
+  const lower = str.toLowerCase();
+  const found = [];
+  const checks = [
+    [/\benglish\b/,           'English'],
+    [/\bjapanese\b/,          'Japanese'],
+    [/\bhindi\b/,             'Hindi'],
+    [/\bfrench\b/,            'French'],
+    [/\bgerman\b/,            'German'],
+    [/\bspanish\b/,           'Spanish'],
+    [/\bitalian\b/,           'Italian'],
+    [/\brussian\b/,           'Russian'],
+    [/\bkorean\b/,            'Korean'],
+    [/\bchinese\b/,           'Chinese'],
+    [/\barabic\b/,            'Arabic'],
+    [/\bportuguese\b/,        'Portuguese'],
+    [/\bturkish\b/,           'Turkish'],
+    [/\bpolish\b/,            'Polish'],
+    [/\bdutch\b/,             'Dutch'],
+    [/\bczech\b/,             'Czech'],
+    [/\bswedish\b/,           'Swedish'],
+    [/\bnorwegian\b/,         'Norwegian'],
+    [/\bdanish\b/,            'Danish'],
+    [/\bfinnish\b/,           'Finnish'],
+    [/\bromanian\b/,          'Romanian'],
+    [/\bgreek\b/,             'Greek'],
+    [/\bhebrew\b/,            'Hebrew'],
+    [/\bthai\b/,              'Thai'],
+    [/\bindonesian\b/,        'Indonesian'],
+    [/\bvietnamese\b/,        'Vietnamese'],
+    [/\btamil\b/,             'Tamil'],
+    [/\btelugu\b/,            'Telugu'],
+    [/\burdu\b/,              'Urdu'],
+    [/\bdubbed\b/,            'Dubbed'],
+    [/\bdual[\s\-]audio\b/,   'Dual Audio'],
+    [/\bmulti[\s\-]audio\b/,  'Multi Audio'],
+    [/\bmulti\b/,             'Multi'],
+  ];
+  for (const [re, label] of checks) {
+    if (re.test(lower)) {
+      if (label === 'Multi' && found.includes('Multi Audio')) continue;
+      found.push(label);
+    }
+  }
+  return [...new Set(found)].join(' / ');
+}
+
+function processStreams(streams, type) {
+  console.log(`[processStreams] Starting with ${streams.length} streams, type: ${type}`);
+  
+  const maxSize = type === 'series' ? MAX_SIZE_GB_SERIES : MAX_SIZE_GB_MOVIE;
+
+  const filtered = streams.filter(s => {
+    if (!s.infoHash && !s.url) {
+      console.log(`[processStreams] Filtering out stream with no infoHash/url`);
+      return false;
+    }
+    if (s._provider && !ALLOWED_PROVIDERS.includes(s._provider.toLowerCase())) {
+      console.log(`[processStreams] Filtering out provider: ${s._provider}`);
+      return false;
+    }
+    const q = s._quality || getQuality(s.title || s.name || '');
+    if (!q || !ALLOWED_QUALITIES.includes(q)) {
+      console.log(`[processStreams] Filtering out quality: ${q}`);
+      return false;
+    }
+    const sizeGB = s._sizeGB ?? getSizeGB(s);
+    if (sizeGB !== null && sizeGB > maxSize) {
+      console.log(`[processStreams] Filtering out oversized: ${sizeGB}GB > ${maxSize}GB`);
+      return false;
+    }
+    return true;
+  });
+
+  console.log(`[processStreams] After filtering: ${filtered.length} streams`);
+
+  const seen   = new Set();
+  const unique = filtered.filter(s => {
+    const key = (s.infoHash || '').toLowerCase();
+    if (!key) return true;
+    if (seen.has(key)) {
+      console.log(`[processStreams] Deduping: ${key}`);
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+
+  console.log(`[processStreams] After dedup: ${unique.length} streams`);
+
+  const byQuality = {};
+  unique.forEach(s => {
+    const q = s._quality || getQuality(s.title || s.name || '') || 'unknown';
+    if (!byQuality[q]) byQuality[q] = [];
+    byQuality[q].push(s);
+  });
+
+  for (const q in byQuality) {
+    byQuality[q].sort((a, b) => {
+      const rankA = PRIORITY_PROVIDERS.indexOf((a._source || '').toLowerCase());
+      const rankB = PRIORITY_PROVIDERS.indexOf((b._source || '').toLowerCase());
+      const pA = rankA === -1 ? 999 : rankA;
+      const pB = rankB === -1 ? 999 : rankB;
+      if (pA !== pB) return pA - pB;
+      return getSeeders(b) - getSeeders(a);
+    });
+  }
+
+  const sortedQualities = Object.keys(byQuality).sort(
+    (a, b) => (QUALITY_RANK[a] || 99) - (QUALITY_RANK[b] || 99)
+  );
+
+  const result = [];
+  sortedQualities.forEach(q => {
+    console.log(`[processStreams] Quality ${q}: ${byQuality[q].length} → taking ${Math.min(LINKS_PER_QUALITY, byQuality[q].length)}`);
+    result.push(...byQuality[q].slice(0, LINKS_PER_QUALITY));
+  });
+  
+  console.log(`[processStreams] Final result: ${result.length} streams`);
+  return result;
+}
+
+async function tmdbLookup(imdbId) {
   try {
+    console.log(`[TMDB] Looking up: ${imdbId}`);
     const { data } = await axios.get(
-      `https://subsplease.org/api/?f=search&tz=&s=${encodeURIComponent(title)}`,
+      `https://api.themoviedb.org/3/find/${imdbId}?api_key=${TMDB_KEY}&external_source=imdb_id`,
       { timeout: 8000 }
     );
+    const movie = data.movie_results?.[0];
+    const tv    = data.tv_results?.[0];
+    if (movie) {
+      console.log(`[TMDB] ✅ Found movie: ${movie.title} (${movie.release_date})`);
+      return { title: movie.title || movie.original_title, year: (movie.release_date || '').slice(0, 4) };
+    }
+    if (tv) {
+      console.log(`[TMDB] ✅ Found TV: ${tv.name} (${tv.first_air_date})`);
+      return { title: tv.name || tv.original_name, year: (tv.first_air_date || '').slice(0, 4) };
+    }
+    console.log(`[TMDB] ❌ No results`);
+    return null;
+  } catch (e) { 
+    console.error('[TMDB] ❌ Error:', e.message); 
+    return null; 
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// SUBSPLEASE SCRAPER
+// ═══════════════════════════════════════════════════════════════════════════
+async function scrapeSubsPlease(title, season, episode) {
+  if (!title) return [];
+  try {
+    console.log(`[SubsPlease] 🔍 Searching: ${title}`);
+    const { data } = await axios.get(
+      `https://subsplease.org/api/?f=search&tz=&s=${encodeURIComponent(title)}`,
+      { timeout: 8000, headers: { 'User-Agent': UA } }
+    );
+    
+    console.log(`[SubsPlease] 📡 Response keys:`, Object.keys(data).slice(0, 3));
+    
+    if (!data || Object.keys(data).length === 0) {
+      console.log(`[SubsPlease] ❌ No results`);
+      return [];
+    }
     
     const streams = [];
-    for (const [key, show] of Object.entries(data || {})) {
-      if (show.downloads) {
-        for (const dl of show.downloads) {
-          if (dl.magnet && dl.res) {
-            streams.push({
-              title: `${show.show_name} ${dl.res}p`,
-              magnet: dl.magnet,
-              res: dl.res,
-              source: 'subsplease'
-            });
-          }
+    for (const [showKey, showData] of Object.entries(data)) {
+      if (!showData.downloads || !Array.isArray(showData.downloads)) continue;
+      
+      console.log(`[SubsPlease] Found: ${showData.show_name} (${showData.downloads.length} downloads)`);
+      
+      for (const dl of showData.downloads) {
+        if (!dl.magnet || !dl.res) continue;
+        
+        if (season && episode) {
+          const epStr = `S${String(season).padStart(2, '0')}E${String(episode).padStart(2, '0')}`;
+          if (!dl.magnet.toLowerCase().includes(epStr.toLowerCase())) continue;
         }
+        
+        const hashMatch = dl.magnet.match(/btih:([a-fA-F0-9]{32,40})/i);
+        const hash = hashMatch ? hashMatch[1] : '';
+        if (!hash) continue;
+        
+        const langLine = getLangLine(dl.magnet);
+        streams.push({
+          infoHash: hash.toLowerCase(),
+          name: `${showData.show_name} ${dl.res}p`,
+          title: `☀️ ${showData.show_name}\n🌱 N/A\n💾 N/A\n🏅 SubsPlease${langLine ? '\n🔊 ' + langLine : ''}`,
+          sources: [],
+          _quality: dl.res === '1080' ? '1080p' : dl.res === '720' ? '720p' : '480p',
+          _seeders: 0,
+          _sizeGB: null,
+          _source: 'subsplease',
+          _provider: 'subsplease',
+        });
       }
     }
-    return { ok: true, count: streams.length, data: streams.slice(0, 3) };
-  } catch (e) {
-    return { ok: false, error: e.message, count: 0, data: [] };
+    console.log(`[SubsPlease] ✅ ${streams.length} results`);
+    return streams;
+  } catch (e) { 
+    console.error('[SubsPlease] ❌', e.message); 
+    return []; 
   }
 }
 
-// APIBay
-async function scrapeAPIBay(title) {
+// ═══════════════════════════════════════════════════════════════════════════
+// APIBAY SCRAPER (THE PIRATE BAY)
+// ═══════════════════════════════════════════════════════════════════════════
+async function scrapeAPIBay(title, year, season, episode) {
+  if (!title) return [];
   try {
+    let query = title;
+    if (season && episode) {
+      query += ` S${String(season).padStart(2, '0')}E${String(episode).padStart(2, '0')}`;
+    } else if (year) {
+      query += ' ' + year;
+    }
+    
+    console.log(`[APIBay] 🔍 Searching: ${query}`);
     const { data } = await axios.get(
-      `https://apibay.org/q.php?q=${encodeURIComponent(title)}&cat=208`,
-      { timeout: 10000 }
+      `https://apibay.org/q.php?q=${encodeURIComponent(query)}&cat=208`,
+      { timeout: 12000, headers: { 'User-Agent': UA } }
     );
     
-    const streams = (data || []).slice(0, 10).map(item => ({
-      title: item.name,
-      seeders: item.seeders || 0,
-      hash: item.info_hash,
-      source: 'apibay'
-    }));
+    console.log(`[APIBay] 📡 Response type: ${typeof data}, is array: ${Array.isArray(data)}`);
+    
+    if (!Array.isArray(data) || data.length === 0) {
+      console.log(`[APIBay] ❌ No results or invalid format`);
+      return [];
+    }
     
-    return { ok: true, count: streams.length, data: streams };
-  } catch (e) {
-    return { ok: false, error: e.message, count: 0, data: [] };
+    const streams = [];
+    for (const item of data) {
+      if (!item.info_hash || !item.name) continue;
+      
+      const magnet = `magnet:?xt=urn:btih:${item.info_hash.toLowerCase()}&dn=${encodeURIComponent(item.name)}${TR}`;
+      const sizeGB = item.size ? parseInt(item.size, 10) / 1073741824 : null;
+      const sizeStr = sizeGB ? sizeGB.toFixed(2) + ' GB' : 'N/A';
+      const langLine = getLangLine(item.name || '');
+      const seeders = item.seeders ? parseInt(item.seeders, 10) : 0;
+      
+      streams.push({
+        infoHash: item.info_hash.toLowerCase(),
+        name: item.name,
+        title: `☀️ ${title}${year ? ' (' + year + ')' : ''}\n🌱 ${seeders}\n💾 ${sizeStr}\n🏅 APIBay${langLine ? '\n🔊 ' + langLine : ''}`,
+        sources: [],
+        _quality: getQuality(item.name || ''),
+        _seeders: seeders,
+        _sizeGB: sizeGB,
+        _source: 'apibay',
+        _provider: 'thepiratebay',
+      });
+    }
+    console.log(`[APIBay] ✅ ${streams.length} results`);
+    return streams;
+  } catch (e) { 
+    console.error('[APIBay] ❌', e.message); 
+    return []; 
   }
 }
 
-// Torrents.csv
-async function scrapeTorrentsCSV(title) {
+// ═══════════════════════════════════════════════════════════════════════════
+// TORRENTS.CSV SCRAPER
+// ═══════════════════════════════════════════════════════════════════════════
+async function scrapeTorrentsCSV(title, year, season, episode) {
+  if (!title) return [];
   try {
+    let query = title;
+    if (season && episode) {
+      query += ` S${String(season).padStart(2, '0')}E${String(episode).padStart(2, '0')}`;
+    } else if (year) {
+      query += ' ' + year;
+    }
+    
+    console.log(`[Torrents.csv] 🔍 Searching: ${query}`);
     const { data } = await axios.get(
-      `https://torrents-csv.com/service/search?q=${encodeURIComponent(title)}`,
-      { timeout: 10000 }
+      `https://torrents-csv.com/service/search?q=${encodeURIComponent(query)}`,
+      { timeout: 12000, headers: { 'User-Agent': UA } }
     );
     
-    const streams = (data || []).slice(0, 10).map(item => ({
-      title: item.name,
-      seeders: item.seeders || 0,
-      hash: item.infohash,
-      source: 'torrentcsv'
-    }));
+    console.log(`[Torrents.csv] 📡 Response type: ${typeof data}, is array: ${Array.isArray(data)}`);
+    
+    if (!Array.isArray(data) || data.length === 0) {
+      console.log(`[Torrents.csv] ❌ No results or invalid format`);
+      return [];
+    }
     
-    return { ok: true, count: streams.length, data: streams };
-  } catch (e) {
-    return { ok: false, error: e.message, count: 0, data: [] };
+    const streams = [];
+    for (const item of data) {
+      if (!item.infohash || !item.name) continue;
+      
+      const magnet = `magnet:?xt=urn:btih:${item.infohash.toLowerCase()}&dn=${encodeURIComponent(item.name)}${TR}`;
+      const sizeGB = item.size ? item.size / 1073741824 : null;
+      const sizeStr = sizeGB ? sizeGB.toFixed(2) + ' GB' : 'N/A';
+      const langLine = getLangLine(item.name || '');
+      const seeders = item.seeders || 0;
+      
+      streams.push({
+        infoHash: item.infohash.toLowerCase(),
+        name: item.name,
+        title: `☀️ ${title}${year ? ' (' + year + ')' : ''}\n🌱 ${seeders}\n💾 ${sizeStr}\n🏅 Torrents.csv${langLine ? '\n🔊 ' + langLine : ''}`,
+        sources: [],
+        _quality: getQuality(item.name || ''),
+        _seeders: seeders,
+        _sizeGB: sizeGB,
+        _source: 'torrentcsv',
+        _provider: 'torrentcsv',
+      });
+    }
+    console.log(`[Torrents.csv] ✅ ${streams.length} results`);
+    return streams;
+  } catch (e) { 
+    console.error('[Torrents.csv] ❌', e.message); 
+    return []; 
   }
 }
 
-// Test endpoint
-app.get('/test/:query', async (req, res) => {
-  const query = decodeURIComponent(req.params.query);
+// ─── Manifest ──────────────────────────────────────────────────────────
+app.get('/manifest.json', (_, res) => {
+  res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate');
+  res.json({
+    id:          'org.ghostream.plus.v2',
+    name:        'VanStreams+',
+    description: 'Stream Everything You Want\nMade With 🤍 By Van',
+    version:     '15.0.7',
+    resources:   ['stream'],
+    types:       ['movie', 'series'],
+    idPrefixes:  ['tt'],
+    catalogs:    [],
+  });
+});
+
+// ─── Stream handler ────────────────────────────────────────────────
+app.get('/stream/:type/:id.json', async (req, res) => {
+  const { type, id } = req.params;
+  const isSeries = type === 'series';
+  const [imdbId, season = '', episode = ''] = id.split(':');
+
+  console.log(`\n${'='.repeat(70)}`);
+  console.log(`[stream] 🎬 Request: ${type}/${id} | Series: ${isSeries}`);
+  console.log(`${'='.repeat(70)}`);
+
+  const meta  = await tmdbLookup(imdbId);
+  const title = meta?.title || '';
+  const year  = meta?.year  || '';
+
+  console.log(`[stream] 📌 Title: ${title} | Year: ${year}`);
+
+  const [subspleaseR, apibayR, torrentscsvR] = await Promise.allSettled([
+    scrapeSubsPlease(title, season, episode),
+    scrapeAPIBay(title, year, season, episode),
+    scrapeTorrentsCSV(title, year, season, episode),
+  ]);
+
+  const subsplease = subspleaseR.status === 'fulfilled' ? (subspleaseR.value || []) : [];
+  const apibay = apibayR.status === 'fulfilled' ? (apibayR.value || []) : [];
+  const torrentscsv = torrentscsvR.status === 'fulfilled' ? (torrentscsvR.value || []) : [];
+
+  console.log(`[stream] 📊 Raw results: subsplease:${subsplease.length} apibay:${apibay.length} torrentscsv:${torrentscsv.length}`);
+
+  const streams = processStreams([...subsplease, ...apibay, ...torrentscsv], type);
+
+  console.log(`[stream] ✅ FINAL: ${streams.length} streams`);
+  console.log(`${'='.repeat(70)}\n`);
+  
+  res.json({ streams });
+});
+
+// ─── Diagnostic endpoints ─────────────────────────────────────────────
+app.get('/diag/:type/:id', async (req, res) => {
+  const { type, id } = req.params;
+  const isSeries = type === 'series';
+  const [imdbId, season = '', episode = ''] = id.split(':');
+  const meta = await tmdbLookup(imdbId);
   
-  const [sp, ab, csv] = await Promise.allSettled([
-    scrapeSubsPlease(query),
-    scrapeAPIBay(query),
-    scrapeTorrentsCSV(query)
+  const [subspleaseR, apibayR, torrentscsvR] = await Promise.allSettled([
+    scrapeSubsPlease(meta?.title || '', season, episode),
+    scrapeAPIBay(meta?.title || '', meta?.year || '', season, episode),
+    scrapeTorrentsCSV(meta?.title || '', meta?.year || '', season, episode),
   ]);
   
   res.json({
-    query,
-    subsplease: sp.status === 'fulfilled' ? sp.value : { ok: false, error: 'Failed', count: 0 },
-    apibay: ab.status === 'fulfilled' ? ab.value : { ok: false, error: 'Failed', count: 0 },
-    torrentcsv: csv.status === 'fulfilled' ? csv.value : { ok: false, error: 'Failed', count: 0 }
+    imdbId, title: meta?.title, year: meta?.year, isSeries,
+    tmdb:       meta ? `✅ ${meta.title} (${meta.year})` : '❌ FAILED',
+    subsplease: { count: (subspleaseR.value || []).length, err: subspleaseR.reason?.message || null },
+    apibay:     { count: (apibayR.value || []).length, err: apibayR.reason?.message || null },
+    torrentcsv: { count: (torrentscsvR.value || []).length, err: torrentscsvR.reason?.message || null },
   });
 });
 
-// Main page
+// ══════════════════════════  LANDING PAGE  ═══════════════════════════
 app.get('/', (req, res) => {
-  res.type('html').send(`
-<!DOCTYPE html>
-<html>
+  const manifestUrl = 'https://vanseleem-vsplus.hf.space/manifest.json';
+  const installUrl  = 'stremio://vanseleem-vsplus.hf.space/manifest.json';
+
+  res.type('html').send(`<!DOCTYPE html>
+<html lang="en">
 <head>
-  <title>Test APIs</title>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>VanStreams+</title>
   <style>
-    body { font-family: Arial; background: #0d1117; color: #c9d1d9; padding: 20px; }
-    .container { max-width: 800px; margin: 0 auto; }
-    h1 { color: #58a6ff; }
-    .test-btn { background: #1f6feb; color: white; padding: 10px 20px; border: none; border-radius: 6px; cursor: pointer; margin: 5px; }
-    .test-btn:hover { background: #388bfd; }
-    pre { background: #161b22; padding: 15px; border-radius: 6px; overflow-x: auto; }
-    .status { padding: 10px; margin: 10px 0; border-radius: 6px; }
-    .ok { background: #0d3922; color: #3fb950; }
-    .error { background: #3d1f1a; color: #ff7b72; }
+    *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      font-family: -apple-system, 'Segoe UI', system-ui, sans-serif;
+      background: #050810;
+      color: #dde6f0;
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      padding: 28px 20px;
+      background-image:
+        radial-gradient(ellipse 70% 40% at 50% 0%, rgba(255,0,0,0.05) 0%, transparent 70%),
+        radial-gradient(ellipse 40% 30% at 80% 80%, rgba(255,0,0,0.03) 0%, transparent 60%);
+    }
+    .wrap { width: 100%; max-width: 560px; display: flex; flex-direction: column; gap: 20px; }
+    .header { display: flex; flex-direction: column; gap: 12px; }
+    .logo { font-size: 2.6rem; font-weight: 800; letter-spacing: -1px; line-height: 1; }
+    .logo .van  { color: #FF0000; }
+    .logo .streams { color: #ffffff; }
+    .badge-row { display: flex; gap: 8px; flex-wrap: wrap; }
+    .badge {
+      display: inline-flex; align-items: center; gap: 5px;
+      background: rgba(255,0,0,0.08); border: 1px solid rgba(255,0,0,0.18);
+      color: #ffffff; padding: 4px 11px; border-radius: 100px;
+      font-size: 0.72rem; font-weight: 700; letter-spacing: 0.4px; text-transform: uppercase;
+    }
+    .badge.series { color: #ffffff; }
+    .desc { color: #ffffff; font-size: 0.9rem; line-height: 1.6; margin-top: 2px; }
+    .card {
+      background: rgba(255,255,255,0.03); border: 1px solid rgba(255,255,255,0.07);
+      border-radius: 16px; padding: 20px 22px;
+    }
+    .card-label { font-size: 0.68rem; font-weight: 700; text-transform: uppercase; letter-spacing: 1px; color: #ffffff; margin-bottom: 10px; }
+    .url-box {
+      font-family: 'SF Mono','Fira Code','Consolas',monospace; font-size: 0.8rem;
+      color: #ffffff; background: rgba(0,0,0,0.25); border: 1px solid rgba(255,0,0,0.12);
+      border-radius: 10px; padding: 11px 14px; word-break: break-all; line-height: 1.5;
+    }
+    .actions { display: flex; gap: 10px; margin-top: 14px; flex-wrap: wrap; }
+    .btn { padding: 10px 22px; border-radius: 10px; font-size: 0.84rem; font-weight: 600; text-decoration: none; border: none; cursor: pointer; transition: all 0.15s; font-family: inherit; }
+    .btn-install {
+      background: #FF0000;
+      color: #ffffff;
+    }
+    .btn-install:hover { background: #cc0000; }
+    .btn-copy {
+      background: #ffffff;
+      color: #050810;
+      border: 1px solid #ffffff;
+    }
+    .btn-copy:hover {
+      background: #e6e6e6;
+      border-color: #e6e6e6;
+    }
+    .stats { display: grid; grid-template-columns: repeat(3, 1fr); gap: 10px; }
+    .stat { background: rgba(255,255,255,0.02); border: 1px solid rgba(255,255,255,0.06); border-radius: 12px; padding: 16px 12px; text-align: center; }
+    .stat-val { font-size: 1.5rem; font-weight: 800; color: #fff; line-height: 1; margin-bottom: 5px; }
+    .stat-lbl { font-size: 0.68rem; color: #aaa; font-weight: 600; text-transform: uppercase; letter-spacing: 0.5px; white-space: pre-line; }
+    .made-by { text-align: center; color: #ffffff; font-size: 0.85rem; margin-top: 6px; opacity: 0.8; }
   </style>
 </head>
 <body>
-  <div class="container">
-    <h1>🧪 Torrent APIs Test</h1>
-    <button class="test-btn" onclick="test('Breaking Bad')">Breaking Bad</button>
-    <button class="test-btn" onclick="test('Solo Leveling')">Solo Leveling</button>
-    <button class="test-btn" onclick="test('The Office')">The Office</button>
-    <input type="text" id="query" placeholder="Custom query" style="padding: 8px; width: 200px; background: #0d1117; color: #c9d1d9; border: 1px solid #30363d; border-radius: 6px;">
-    <button class="test-btn" onclick="customTest()">Search</button>
-    <pre id="result">Click a button to test...</pre>
+  <div class="wrap">
+    <div class="header">
+      <div class="logo">
+        <span class="van">Van</span> <span class="streams">Streams+</span>
+      </div>
+      <div class="badge-row">
+        <span class="badge">🎬 Movies</span>
+        <span class="badge series">📺 Series</span>
+      </div>
+      <p class="desc">Get Your 🍿 Ready</p>
+    </div>
+    <div class="card">
+      <div class="card-label">Stremio Install URL</div>
+      <div class="url-box">${manifestUrl}</div>
+      <div class="actions">
+        <a href="${installUrl}" class="btn btn-install">Install in Stremio</a>
+        <button class="btn btn-copy" onclick="navigator.clipboard.writeText('${manifestUrl}').then(()=>{this.textContent='✔ Copied';setTimeout(()=>this.textContent='Copy URL',2000)})">Copy URL</button>
+      </div>
+    </div>
+    <div class="stats">
+      <div class="stat"><div class="stat-val">100K+</div><div class="stat-lbl">Movies</div></div>
+      <div class="stat"><div class="stat-val">40K+</div><div class="stat-lbl">Series</div></div>
+      <div class="stat"><div class="stat-val">20K+</div><div class="stat-lbl">Anime</div></div>
+    </div>
+    <div class="made-by">Made With 🤍 By Van</div>
   </div>
-  
-  <script>
-    async function test(q) {
-      document.getElementById('result').textContent = 'Loading...';
-      try {
-        const res = await fetch('/test/' + encodeURIComponent(q));
-        const data = await res.json();
-        document.getElementById('result').textContent = JSON.stringify(data, null, 2);
-      } catch (e) {
-        document.getElementById('result').textContent = 'Error: ' + e.message;
-      }
-    }
-    
-    function customTest() {
-      const q = document.getElementById('query').value;
-      if (q) test(q);
-    }
-  </script>
 </body>
-</html>
-  `);
+</html>`);
 });
 
 app.listen(PORT, '0.0.0.0', () => {
-  console.log(`✅ Running on port ${PORT}`);
+  console.log(`\n${'='.repeat(70)}`);
+  console.log(`✅ VanStreams+ Running on port ${PORT}`);
+  console.log(`🔗 http://localhost:${PORT}/`);
+  console.log(`📊 Diagnostics: http://localhost:${PORT}/diag/series/tt1234567:1:1`);
+  console.log(`${'='.repeat(70)}\n`);
 });