Update index.js

index.js

@@ -12,7 +12,7 @@ const app  = express();
 const PORT = process.env.PORT || 7860;
 
 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);
@@ -21,13 +21,33 @@ app.use((req, res, next) => {
 
 // ── Config ───────────────────────────────────────────────────────
 const BASE         = 'https://subf2m.co';
-const TMDB_KEY     = '30166e2db6b420d3f230808cd1bb2c90';
-const TMDB_BASE    = 'https://api.themoviedb.org/3';
-const MAX_PER_LANG = 4;               // final output per language
+const MAX_PER_LANG = 4;
 const CACHE_TTL    = 6 * 60 * 60 * 1000;
 const REQ_TIMEOUT  = 15_000;
 const DL_TIMEOUT   = 25_000;
-const MAX_DETAIL   = 50;              // how many subtitles to deep‑scan per page
+const MAX_DETAIL   = 50;
+
+const SEASON_WORDS = [
+  'first season', 'second season', 'third season', 'fourth season', 'fifth season',
+  'sixth season', 'seventh season', 'eighth season', 'ninth season', 'tenth season',
+  'eleventh season', 'twelfth season', 'thirteenth season', 'fourteenth season',
+  'fifteenth season', 'sixteenth season'
+];
+
+const ALLOWED_LANGS = new Set(['english', 'arabic']);
+
+// ── AI patterns ──────────────────────────────────────────────────
+const AI_PATTERNS = [
+  /\ba\.i\.\b/i, /\bai[\s\-_]sub(title)?s?\b/i, /\bai[\s\-_](translat|generat|correct|made|creat)/i,
+  /(translat|generat|creat|made|sub(title)?s?)\s+(by\s+)?ai\b/i, /machine[\s\-_]translat/i, /auto[\s\-_]?translat/i,
+  /auto[\s\-_]?generat/i, /auto[\s\-_]?sub(title)?s?\b/i, /\bautosub\b/i, /\bchatgpt\b/i, /\bgpt[\s\-_]?[34o]?\b/i,
+  /\bdeep[\s\-_]?l\b/i, /google[\s\-_]translat/i, /yandex[\s\-_]translat/i, /amazon[\s\-_]translat/i,
+  /microsoft[\s\-_]translat/i, /bing[\s\-_]translat/i, /\bopenai\b/i, /\bwhisper\b/i, /\bgemini\b/i, /\bclaude\b/i,
+  /\bllama\b/i, /neural[\s\-_](translat|sub|net|machine)/i, /\bnmt\b/i, /artificial[\s\-_]intelligence/i,
+  /computer[\s\-_](translat|generat)/i,
+];
+
+function isAISub(text) { return AI_PATTERNS.some(rx => rx.test(text || '')); }
 
 // ── Globals ───────────────────────────────────────────────────────
 const cache    = new Map();
@@ -125,268 +145,62 @@ function cacheSet(key, val) {
   cache.set(key, { val, ts: Date.now() });
 }
 
-// ── TMDB ───────────────────────────────────────────────────────────
-async function getTMDB(imdbId) {
-  const ck = `tmdb:${imdbId}`;
+// ── Slug resolution via IMDb ID (the whole trick) ─────────────────
+async function resolveSlugByImdb(imdbId, season) {
+  const ck = `imdbslug:${imdbId}:${season ?? 'movie'}`;
   const hit = cacheGet(ck);
   if (hit !== null) return hit;
-  try {
-    const raw = await _request(`${TMDB_BASE}/find/${imdbId}?external_source=imdb_id&api_key=${TMDB_KEY}`, { timeout: 8000 });
-    if (!raw) { cacheSet(ck, null); return null; }
-    const d = JSON.parse(raw);
-    let info = null;
-    if (d.movie_results?.length) {
-      const m = d.movie_results[0];
-      info = { title: m.title || m.original_title, year: m.release_date?.substring(0,4), type: 'movie', tmdbId: m.id };
-    } else if (d.tv_results?.length) {
-      const t = d.tv_results[0];
-      info = { title: t.name || t.original_name, year: t.first_air_date?.substring(0,4), type: 'series', tmdbId: t.id };
-    }
-    cacheSet(ck, info);
-    return info;
-  } catch { cacheSet(ck, null); return null; }
-}
-
-async function getTMDBSeasonYear(tmdbId, season) {
-  if (!tmdbId) return null;
-  const ck = `tmdbseason:${tmdbId}:${season}`;
-  const hit = cacheGet(ck);
-  if (hit !== null) return hit;
-  try {
-    const raw = await _request(`${TMDB_BASE}/tv/${tmdbId}/season/${season}?api_key=${TMDB_KEY}`, { timeout: 8000 });
-    if (!raw) { cacheSet(ck, null); return null; }
-    const d = JSON.parse(raw);
-    const year = d.air_date?.substring(0,4) || null;
-    cacheSet(ck, year);
-    return year;
-  } catch { cacheSet(ck, null); return null; }
-}
-
-// ── Slug utilities ─────────────────────────────────────────────────
-function titleToSlug(title, year) {
-  const base = (title || '').toLowerCase()
-    .normalize('NFD').replace(/[\u0300-\u036f]/g, '')
-    .replace(/[^a-z0-9\s]/g, '')
-    .replace(/\s+/g, '-')
-    .replace(/-+/g, '-')
-    .replace(/^-|-$/g, '');
-  return year ? `${base}-${year}` : base;
-}
 
-// ── Language & AI filters ─��────────────────────────────────────────
-const ALLOWED_LANGS = new Set(['english', 'arabic']);
-
-const AI_PATTERNS = [
-  /\ba\.i\.\b/i, /\bai[\s\-_]sub(title)?s?\b/i, /\bai[\s\-_](translat|generat|correct|made|creat)/i,
-  /(translat|generat|creat|made|sub(title)?s?)\s+(by\s+)?ai\b/i, /machine[\s\-_]translat/i, /auto[\s\-_]?translat/i,
-  /auto[\s\-_]?generat/i, /auto[\s\-_]?sub(title)?s?\b/i, /\bautosub\b/i, /\bchatgpt\b/i, /\bgpt[\s\-_]?[34o]?\b/i,
-  /\bdeep[\s\-_]?l\b/i, /google[\s\-_]translat/i, /yandex[\s\-_]translat/i, /amazon[\s\-_]translat/i,
-  /microsoft[\s\-_]translat/i, /bing[\s\-_]translat/i, /\bopenai\b/i, /\bwhisper\b/i, /\bgemini\b/i, /\bclaude\b/i,
-  /\bllama\b/i, /neural[\s\-_](translat|sub|net|machine)/i, /\bnmt\b/i, /artificial[\s\-_]intelligence/i,
-  /computer[\s\-_](translat|generat)/i,
-];
-
-function isAISub(text) {
-  return AI_PATTERNS.some(rx => rx.test(text || ''));
-}
-
-// ── Episode parsing from filename ──────────────────────────────────
-function seasonEpisodeFromFilename(text) {
-  if (!text) return { season: null, episode: null };
-  const n = text.toLowerCase();
-  const m1 = n.match(/s(\d{1,2})[\.\-_\s]?e(\d{1,3})/);
-  if (m1) return { season: parseInt(m1[1], 10), episode: parseInt(m1[2], 10) };
-  const m2 = n.match(/[._\-\s](\d{1,2})x(\d{1,3})[._\-\s]/);
-  if (m2) return { season: parseInt(m2[1], 10), episode: parseInt(m2[2], 10) };
-  return { season: null, episode: null };
-}
-
-// ── Slug resolution ────────────────────────────────────────────────
-async function _probeSlug(slug, expectedTitle) {
-  if (!slug) return false;
-  try {
-    const html = await getHTML(`${BASE}/subtitles/${slug}/english`);
-    if (!html || html.length < 2000) return false;
-    if (expectedTitle) {
-      const $ = cheerio.load(html);
-      const pageTitle = ($('title').text() || '').toLowerCase();
-      return pageTitle.includes(expectedTitle.toLowerCase());
-    }
-    return true;
-  } catch { return false; }
-}
-
-async function _searchSlug(query, yearHint) {
-  const url = `${BASE}/subtitles/searchbytitle?query=${encodeURIComponent(query)}&l=`;
+  const url = `${BASE}/subtitles/searchbytitle?query=${imdbId}&l=`;
+  console.log(`[IMDb] Searching: ${url}`);
   const html = await getHTML(url);
-  if (!html) return null;
+  if (!html) { cacheSet(ck, null); return null; }
+
   const $ = cheerio.load(html);
   const results = [];
-  $('a[href*="/subtitles/"]').each((_, a) => {
-    const href = $(a).attr('href');
-    if (!href || href === '/subtitles/searchbytitle') return;
+
+  // Parse all search results
+  $('li div.title a').each((_, a) => {
+    const href = $(a).attr('href') || '';
+    if (!href.startsWith('/subtitles/')) return;
     const parts = href.split('/').filter(Boolean);
     if (parts.length < 2) return;
     const slug = parts[1];
-    if (!slug || slug === 'searchbytitle') return;
-    const text = $(a).text().trim();
-    const yrMatch = text.match(/\((\d{4})\)/);
-    const resYear = yrMatch ? +yrMatch[1] : null;
-    let score = 1;
-    if (query.startsWith('tt')) score += 100;
-    if (yearHint && resYear === +yearHint) score += 10;
-    results.push({ slug, score });
+    const text = $(a).text().trim().toLowerCase();
+    results.push({ slug, text });
   });
-  if (!results.length) return null;
-  results.sort((a, b) => b.score - a.score);
-  return results[0].slug;
-}
-
-async function resolveMovieSlug(imdbId, titleHint, yearHint) {
-  const ck = `mslug:${imdbId}`;
-  const hit = cacheGet(ck);
-  if (hit !== null) return hit;
-
-  const tmdb = await getTMDB(imdbId);
-  const title = tmdb?.title || titleHint;
-  const year  = tmdb?.year  || yearHint;
-
-  let slug = await _searchSlug(imdbId, yearHint);
-  if (slug && await _probeSlug(slug, title)) { cacheSet(ck, slug); return slug; }
 
-  if (title) {
-    slug = await _searchSlug(title, year);
-    if (slug && await _probeSlug(slug, title)) { cacheSet(ck, slug); return slug; }
-
-    const candidates = [];
-    if (year) candidates.push(titleToSlug(title, year));
-    candidates.push(titleToSlug(title, null));
-    if (year) {
-      candidates.push(titleToSlug(title, String(+year - 1)));
-      candidates.push(titleToSlug(title, String(+year + 1)));
-    }
-    for (const c of candidates) {
-      await sleep(300);
-      if (await _probeSlug(c, title)) { cacheSet(ck, c); return c; }
-    }
+  if (!results.length) {
+    console.log(`[IMDb] No results for ${imdbId}`);
+    cacheSet(ck, null);
+    return null;
   }
-  cacheSet(ck, null);
-  return null;
-}
-
-const SEASON_WORDS = [
-  '', 'first', 'second', 'third', 'fourth', 'fifth',
-  'sixth', 'seventh', 'eighth', 'ninth', 'tenth',
-  'eleventh', 'twelfth', 'thirteenth', 'fourteenth', 'fifteenth'
-];
-
-async function _probeSeriesSlugFast(slug, season) {
-  if (!slug || slug.length > 200) return false;
-  try {
-    const html = await getHTML(`${BASE}/subtitles/${slug}/english`, 1);
-    if (!html || html.length < 800) return false;
-    const s2 = String(season).padStart(2, '0');
-    return html.includes(`S${s2}E`) || html.includes(`s${s2}e`) ||
-           html.includes(`Season ${season}`) || html.includes(`season ${season}`) ||
-           new RegExp(`\\bs${s2}e\\d`, 'i').test(html);
-  } catch { return false; }
-}
-
-async function resolveSeriesSlug(imdbId, season) {
-  const ck = `sslug:${imdbId}:${season}`;
-  const hit = cacheGet(ck);
-  if (hit !== null) return hit;
-
-  const tmdb = await getTMDB(imdbId);
-  const title = tmdb?.title;
-  if (!title) { cacheSet(ck, null); return null; }
-
-  // 1) TMDB-informed patterns
-  const seasonYear = tmdb?.tmdbId ? await getTMDBSeasonYear(tmdb.tmdbId, season) : null;
-  let slug = await _smartPatterns(title, season, seasonYear, tmdb?.year);
-  if (slug) { cacheSet(ck, slug); return slug; }
 
-  // 2) Site search
-  slug = await _searchSeriesSlug(title, season);
-  if (slug) { cacheSet(ck, slug); return slug; }
+  console.log(`[IMDb] Found ${results.length} result(s)`);
 
-  // 3) Bare title page (all seasons)
-  const baseSlug = titleToSlug(title, null);
-  if (await _probeSeriesSlugFast(baseSlug, season)) { cacheSet(ck, baseSlug); return baseSlug; }
-
-  cacheSet(ck, null);
-  return null;
-}
-
-async function _smartPatterns(title, season, seasonYear, showYear) {
-  const base = titleToSlug(title, null);
-  const ord  = SEASON_WORDS[season] || '';
-  const pad  = String(season).padStart(2, '0');
-  const patterns = [];
-
-  if (seasonYear) {
-    if (ord) {
-      patterns.push(`${base}-${ord}-season-${seasonYear}`);
-      patterns.push(`${base}--${ord}-season-${seasonYear}`);
-      patterns.push(`${base}-${ord}-season-tv-${seasonYear}`);
-    }
-    patterns.push(`${base}-season-${season}-${seasonYear}`);
-    patterns.push(`${base}-s${pad}-${seasonYear}`);
-    patterns.push(`${base}-${seasonYear}`);
+  // For movies (no season requested), return the first result
+  if (!season) {
+    const slug = results[0].slug;
+    console.log(`[IMDb] Movie slug: ${slug}`);
+    cacheSet(ck, slug);
+    return slug;
   }
 
-  if (ord) {
-    patterns.push(`${base}-${ord}-season`);
-    patterns.push(`${base}--${ord}-season`);
-  }
-  patterns.push(`${base}-season-${season}`);
-  patterns.push(`${base}-s${pad}`);
-
-  const yearBase = seasonYear ? +seasonYear : (showYear ? +showYear : null);
-  if (yearBase) {
-    for (const yr of [yearBase - 1, yearBase + 1]) {
-      if (ord) patterns.push(`${base}-${ord}-season-${yr}`);
-      patterns.push(`${base}-season-${season}-${yr}`);
-      patterns.push(`${base}-${yr}`);
+  // For series, find the matching season
+  const seasonWord = SEASON_WORDS[season - 1] || '';
+  if (seasonWord) {
+    const match = results.find(r => r.text.includes(seasonWord));
+    if (match) {
+      console.log(`[IMDb] Series S${season} slug: ${match.slug}`);
+      cacheSet(ck, match.slug);
+      return match.slug;
     }
   }
 
-  const unique = [...new Set(patterns)].filter(Boolean);
-  for (const s of unique) {
-    await sleep(150);
-    if (await _probeSeriesSlugFast(s, season)) return s;
-  }
-  return null;
-}
-
-async function _searchSeriesSlug(title, season) {
-  const url = `${BASE}/subtitles/searchbytitle?query=${encodeURIComponent(title)}&l=`;
-  const html = await getHTML(url);
-  if (!html) return null;
-  const $ = cheerio.load(html);
-  const firstWord = titleToSlug(title, null).split('-')[0];
-  const results = [];
-  $('a[href*="/subtitles/"]').each((_, a) => {
-    const href = $(a).attr('href');
-    if (!href || href === '/subtitles/searchbytitle') return;
-    const parts = href.split('/').filter(Boolean);
-    if (parts.length < 2) return;
-    const slug = parts[1];
-    if (!slug || slug === 'searchbytitle') return;
-    const slugLow = slug.toLowerCase();
-    if (!slugLow.startsWith(firstWord)) return;
-    let score = 0;
-    if (SEASON_WORDS[season] && slugLow.includes(`${SEASON_WORDS[season]}-season`)) score += 100;
-    if (slugLow.includes(`season-${season}`)) score += 90;
-    if (slugLow.includes(`-s${String(season).padStart(2,'0')}`)) score += 80;
-    if (score > 0) results.push({ slug, score });
-  });
-  results.sort((a, b) => b.score - a.score);
-  for (const r of results.slice(0, 5)) {
-    await sleep(200);
-    if (await _probeSeriesSlugFast(r.slug, season)) return r.slug;
-  }
-  return null;
+  // Fallback: return the first result (may be the base show page)
+  console.log(`[IMDb] No exact season match, using first result: ${results[0].slug}`);
+  cacheSet(ck, results[0].slug);
+  return results[0].slug;
 }
 
 // ── Subtitle scraping ──────────────────────────────────────────────
@@ -461,7 +275,6 @@ async function getSubsList(slug, lang) {
   });
 
   if (!raw.length) {
-    // fallback: any link to a subtitle detail page
     $('a[href]').each((_, a) => {
       const href = $(a).attr('href') || '';
       if (!href.includes(`/${lang}/`) || !/\/\d+$/.test(href)) return;
@@ -480,47 +293,18 @@ async function getSubsList(slug, lang) {
   return enriched;
 }
 
-// ── Scoring (purely logical) ───────────────────────────────────────
+// ── Scoring ────────────────────────────────────────────────────────
 const OFFICIAL_SOURCES = ['netflix','nf','amzn','amazon','osn','shahid','wavo','hbo','hulu','disney','dsnp','appletv','atvp'];
 
-function scoreTrack(sub, streamTitle, season, episode) {
+function scoreTrack(sub) {
   const text = (sub.releaseInfo || '').toLowerCase();
   let s = 0;
 
-  // 1) Episode match
-  if (season != null && episode != null) {
-    const parsed = seasonEpisodeFromFilename(text);
-    if (parsed.season !== null && parsed.episode !== null) {
-      if (parsed.season === season && parsed.episode === episode) s += 300;
-      else s -= 150;                                 // explicitly wrong
-    } else if (parsed.season !== null && parsed.season !== season) {
-      s -= 150;
-    }
-    // no info → neutral
-  }
-
-  // 2) Official streaming source
   if (OFFICIAL_SOURCES.some(src => text.includes(src))) s += 150;
-
-  // 3) Sync keywords
-  if (/\b(synced|resync|corrected|fixed|proper|repack|retail|perfect\.sync|sync\.fix)\b/i.test(text)) s += 80;
-
-  // 4) Release group match between subtitle and stream filename
-  const strmTitle = (streamTitle || '').toLowerCase();
-  const subGroups = text.match(/\b(?:-([a-z0-9]{2,20}))\b/g) || [];
-  for (const g of subGroups) {
-    const group = g.replace(/^-/, '');
-    if (group && strmTitle.includes(group)) { s += 100; break; }
-  }
-
-  // 5) Hearing impaired penalty
+  if (/\b(synced|resync|corrected|fixed|proper|repack|retail|sync\.fix)\b/i.test(text)) s += 80;
   if (/\b(sdh|hi\.|hi_|hearing.impaired)\b/i.test(text) || sub.hearingImpaired) s -= 40;
-
-  // 6) Community rating
   if (sub.rating) s += Math.round((sub.rating || 0) * 4);
-
-  // 7) ASS/SSA bonus (styling)
-  if (/\.(ass|ssa)$/i.test(text)) s += 5;
+  if (/\.(ass|ssa)$/i.test(sub.releaseInfo || '')) s += 5;
 
   return s;
 }
@@ -574,10 +358,10 @@ async function resolveUrl(downloadUrl, lang, season, episode) {
 const BASE_URL = process.env.SPACE_HOST ? `https://${process.env.SPACE_HOST}` : `http://localhost:${PORT}`;
 
 app.get('/manifest.json', (req, res) => res.json({
-  id:          'org.van.vansubs.v1',
-  name:        'VanSubs+ (Subf2m)',
-  description: 'Human-verified Arabic & English. No AI. Streaming priority.',
-  version:     '2.0.0',
+  id:          'org.van.vansubs.v3',
+  name:        'VanSubs+ (Subf2m IMDb)',
+  description: 'Human-verified Arabic & English. IMDb-direct. No AI.',
+  version:     '3.0.0',
   resources:   ['subtitles'],
   types:       ['movie', 'series'],
   idPrefixes:  ['tt'],
@@ -614,19 +398,14 @@ app.get('/subtitles/:type/:id/:extra?.json', async (req, res) => {
     const extra = req.params.extra ? decodeURIComponent(req.params.extra.replace('.json','')) : '';
     const streamTitle = (extra.match(/filename=([^&]+)/i) || [])[1] || '';
 
-    console.log(`\n╔═ [Subf2m v2] ${type.toUpperCase()} ${imdbId}` +
+    console.log(`\n╔═ [Subf2m v3] ${type.toUpperCase()} ${imdbId}` +
       (season ? ` S${String(season).padStart(2,'0')}E${String(episode??0).padStart(2,'0')}` : '') +
       (streamTitle ? `\n║  hint: "${streamTitle}"` : ''));
 
-    // --- slug ---
-    let slug;
-    if (type === 'series' && season) {
-      slug = await resolveSeriesSlug(imdbId, season);
-    } else {
-      const tmdb = await getTMDB(imdbId);
-      slug = await resolveMovieSlug(imdbId, tmdb?.title || null, tmdb?.year || null);
-    }
+    // --- IMDb-direct slug resolution ---
+    const slug = await resolveSlugByImdb(imdbId, season);
     if (!slug) return res.json({ subtitles: [] });
+    console.log(`║  Slug: ${slug}`);
 
     // --- fetch subtitles ---
     const [engSubs, araSubs] = await Promise.all([
@@ -634,30 +413,28 @@ app.get('/subtitles/:type/:id/:extra?.json', async (req, res) => {
       getSubsList(slug, 'arabic')
     ]);
 
-    // --- filter by episode if series ---
+    // --- episode filter ---
     let engFiltered = engSubs, araFiltered = araSubs;
     if (type === 'series' && season && episode) {
       const expected = `s${String(season).padStart(2,'0')}e${String(episode).padStart(2,'0')}`;
-      engFiltered = engSubs.filter(s => (s.releaseInfo||'').toLowerCase().includes(expected));
-      araFiltered = araSubs.filter(s => (s.releaseInfo||'').toLowerCase().includes(expected));
-      if (!engFiltered.length && !araFiltered.length) {
-        // fallback: keep all (season pack)
-        engFiltered = engSubs; araFiltered = araSubs;
+      const engExact = engSubs.filter(s => (s.releaseInfo||'').toLowerCase().includes(expected));
+      const araExact = araSubs.filter(s => (s.releaseInfo||'').toLowerCase().includes(expected));
+      if (engExact.length || araExact.length) {
+        engFiltered = engExact;
+        araFiltered = araExact;
       }
     }
 
     // --- score & sort ---
-    const scoreAndSort = (arr) => {
-      return arr.map(s => ({
-        ...s,
-        score: scoreTrack(s, streamTitle, season, episode)
-      }))
-      .sort((a, b) => b.score - a.score)
-      .slice(0, MAX_PER_LANG);
+    const processList = (list) => {
+      return list
+        .map(s => ({ ...s, score: scoreTrack(s) }))
+        .sort((a, b) => b.score - a.score)
+        .slice(0, MAX_PER_LANG);
     };
 
-    const engTop = scoreAndSort(engFiltered);
-    const araTop = scoreAndSort(araFiltered);
+    const engTop = processList(engFiltered);
+    const araTop = processList(araFiltered);
 
     // --- resolve ZIPs in parallel ---
     const resolveAll = async (arr) => {
@@ -700,4 +477,4 @@ app.get('/subtitles/:type/:id/:extra?.json', async (req, res) => {
   }
 });
 
-app.listen(PORT, '0.0.0.0', () => console.log(`\n✅ Subf2m engine running → http://0.0.0.0:${PORT}`));
+app.listen(PORT, '0.0.0.0', () => console.log(`\n✅ Subf2m v3 (IMDb-direct) → http://0.0.0.0:${PORT}`));