kuramanime-api 1.0.0

package/src/index.js

@@ -0,0 +1,97 @@
+const express = require('express');
+const cors = require('cors');
+const rateLimit = require('express-rate-limit');
+const config = require('./config');
+const animeRoutes = require('./routes/anime');
+const statusRoutes = require('./routes/status');
+
+const app = express();
+const isVercel = !!process.env.VERCEL;
+
+// ── Middleware ──────────────────────────────────────────
+app.use(cors());
+app.use(express.json());
+
+// Rate limiting — search gets stricter limits
+const searchLimiter = rateLimit({
+  windowMs: 60 * 1000,
+  max: 20,
+  standardHeaders: true,
+  legacyHeaders: false,
+  message: { success: false, error: 'Too many search requests' },
+});
+
+const episodeLimiter = rateLimit({
+  windowMs: 60 * 1000,
+  max: 30,
+  standardHeaders: true,
+  legacyHeaders: false,
+  message: { success: false, error: 'Too many episode requests' },
+});
+
+const apiLimiter = rateLimit({
+  windowMs: 60 * 1000,
+  max: 60,
+  standardHeaders: true,
+  legacyHeaders: false,
+  message: { success: false, error: 'Too many requests, slow down.' },
+});
+
+// Apply rate limiters
+app.use('/api/search', searchLimiter);
+app.use(/\/api\/anime\/[^/]+\/\d+/, episodeLimiter);
+app.use('/api', apiLimiter);
+
+// ── Routes ──────────────────────────────────────────────
+app.get('/', (_req, res) => {
+  res.json({
+    name: 'Kuramanime API',
+    version: '1.0.0',
+    source: config.nodeEnv === 'development' ? config.browserFarm.baseUrl : 'kuramanime',
+    deployed: isVercel ? 'Vercel' : 'self-hosted',
+    endpoints: {
+      'GET /api/anime?page=1': 'List anime terbaru',
+      'GET /api/anime/:slug': 'Detail anime + daftar episode',
+      'GET /api/anime/:slug/:episode': 'Streaming URL per episode',
+      'GET /api/search?q=judul': 'Search anime',
+      'GET /api/status': 'Status source URL',
+      'GET /api/sources': 'List semua source URL',
+      'GET /api/health': 'Server health check',
+      'POST /api/sources/check': 'Trigger manual source update',
+      'POST /api/cache/clear': 'Clear cache',
+    },
+  });
+});
+
+app.use('/api', animeRoutes);
+app.use('/api', statusRoutes);
+
+// ── 404 ─────────────────────────────────────────────────
+app.use((_req, res) => {
+  res.status(404).json({ success: false, error: 'Not found' });
+});
+
+// ── Error handler ───────────────────────────────────────
+app.use((err, _req, res, _next) => {
+  console.error('[ERROR]', err.message);
+  res.status(500).json({ success: false, error: err.message || 'Internal server error' });
+});
+
+// ── Start (skip listen on Vercel) ───────────────────────
+if (!isVercel) {
+  app.listen(config.port, () => {
+    console.log(`🎬 Kuramanime API running on port ${config.port}`);
+    console.log(`   Env: ${config.nodeEnv}`);
+    console.log(`   Source: ${require('./config/sources').getPrimary()}`);
+
+    // Start auto-update scheduler
+    try {
+      const { initSourceUpdater } = require('./services/sourceUpdater');
+      initSourceUpdater();
+    } catch (err) {
+      console.log('[WARN] Source updater disabled (Vercel mode)');
+    }
+  });
+}
+
+module.exports = app;

package/src/routes/anime.js

@@ -0,0 +1,260 @@
+const { Router } = require('express');
+const cheerio = require('cheerio');
+const cheerioScraper = require('../scrapers/cheerio');
+const browserScraper = require('../scrapers/browser');
+const browserFarm = require('../services/browserFarm');
+const { cacheGet, cacheSet } = require('../db');
+
+const router = Router();
+
+// ── GET /api/anime ──────────────────────────────────────
+router.get('/anime', async (req, res, next) => {
+  try {
+    const page = parseInt(req.query.page) || 1;
+    const cacheKey = `anime_list_page_${page}`;
+    const cached = cacheGet(cacheKey);
+    if (cached) return res.json(cached);
+
+    // Use browser-farm for JS-rendered homepage
+    let html, usedUrl;
+    try {
+      const result = await cheerioScraper.fetchWithFallback(`/anime?page=${page}`, true);
+      html = result.html;
+      usedUrl = result.usedUrl;
+    } catch (e) {
+      // Fallback to direct HTTP
+      const result = await cheerioScraper.fetchWithFallback(`/anime?page=${page}`, false);
+      html = result.html;
+      usedUrl = result.usedUrl;
+    }
+
+    const $ = cheerio.load(html);
+    const data = cheerioScraper.scrapeAnimeCards($);
+
+    const result = {
+      success: true,
+      page,
+      source: usedUrl,
+      count: data.length,
+      data,
+    };
+
+    cacheSet(cacheKey, result, 1800);
+    res.json(result);
+  } catch (err) {
+    next(err);
+  }
+});
+
+// ── GET /api/anime/:slug ────────────────────────────────
+router.get('/anime/:slug', async (req, res, next) => {
+  try {
+    const { slug } = req.params;
+    const cacheKey = `anime_detail_${slug}`;
+    const cached = cacheGet(cacheKey);
+    if (cached) return res.json(cached);
+
+    // Find anime ID — try quicksearch first, then scan list pages
+    let found = null;
+    let usedUrl = "";
+
+    // Strategy 1: Quicksearch for slug match (fast, covers all anime)
+    try {
+      const { json } = await cheerioScraper.fetchQuickSearch(slug.replace(/-/g, " ").split(" ")[0]);
+      if (json.html) {
+        const q$ = cheerio.load(json.html);
+        const qResults = cheerioScraper.scrapeQuickSearchResults(q$);
+        found = qResults.find(c => c.slug === slug);
+        if (found) usedUrl = "quicksearch";
+      }
+    } catch (e) {
+      console.warn("[detail] Quicksearch lookup failed:", e.message);
+    }
+
+    // Strategy 2: Scan anime list pages (fallback, up to page 10)
+    if (!found) {
+      for (let page = 1; page <= 10; page++) {
+        try {
+          let html;
+          try {
+            const result = await cheerioScraper.fetchWithFallback(`/anime?page=${page}`, true);
+            html = result.html;
+            usedUrl = result.usedUrl;
+          } catch {
+            const result = await cheerioScraper.fetchWithFallback(`/anime?page=${page}`, false);
+            html = result.html;
+            usedUrl = result.usedUrl;
+          }
+          const list$ = cheerio.load(html);
+          const cards = cheerioScraper.scrapeAnimeCards(list$);
+          found = cards.find(c => c.slug === slug);
+          if (found) break;
+        } catch (e) {
+          console.warn(`[detail] List page ${page} failed:`, e.message);
+        }
+      }
+    }
+
+    if (!found) return res.status(404).json({ success: false, error: "Anime not found" });
+
+    // Fetch detail page
+    let detailHtml;
+    try {
+      const result = await cheerioScraper.fetchWithFallback(`/anime/${found.id}/${slug}`, true);
+      detailHtml = result.html;
+    } catch {
+      const result = await cheerioScraper.fetchWithFallback(`/anime/${found.id}/${slug}`, false);
+      detailHtml = result.html;
+    }
+
+    const $ = cheerio.load(detailHtml);
+    const detail = cheerioScraper.scrapeAnimeDetail($);
+
+    const result = {
+      success: true,
+      data: {
+        id: found.id,
+        slug,
+        ...detail,
+      },
+      source: usedUrl,
+    };
+
+    cacheSet(cacheKey, result, 3600);
+    res.json(result);
+  } catch (err) {
+    next(err);
+  }
+});
+
+// ── GET /api/anime/:slug/:episode ───────────────────────
+router.get('/anime/:slug/:episode', async (req, res, next) => {
+  try {
+    const { slug, episode } = req.params;
+    const serverId = req.query.server || 'kuramadrive';
+    const cacheKey = `episode_${slug}_${episode}_${serverId}`;
+    const cached = cacheGet(cacheKey);
+    if (cached) return res.json(cached);
+
+    // Get anime ID from cache or list
+    const listCacheKey = 'anime_list_page_1';
+    let listData = cacheGet(listCacheKey);
+    if (!listData) {
+      let html;
+      try {
+        const result = await cheerioScraper.fetchWithFallback('/anime', true);
+        html = result.html;
+      } catch {
+        const result = await cheerioScraper.fetchWithFallback('/anime', false);
+        html = result.html;
+      }
+      const $ = cheerio.load(html);
+      listData = { data: cheerioScraper.scrapeAnimeCards($) };
+    }
+    const anime = listData.data.find(c => c.slug === slug);
+
+    // Use browser to get streaming URL
+    let streamData;
+    try {
+      streamData = await browserScraper.getStreamWithServer(slug, episode, serverId);
+    } catch (browserErr) {
+      console.warn('[episode] Browser farm error, using static scrape:', browserErr.message);
+      // Static scrape for server list
+      try {
+        let epHtml;
+        try {
+          const result = await cheerioScraper.fetchWithFallback(`/anime/${slug}/episode/${episode}`, true);
+          epHtml = result.html;
+        } catch {
+          const result = await cheerioScraper.fetchWithFallback(`/anime/${slug}/episode/${episode}`, false);
+          epHtml = result.html;
+        }
+        const $ = cheerio.load(epHtml);
+        streamData = cheerioScraper.scrapeEpisodePage($);
+      } catch {
+        streamData = { episodes: [], servers: [], credit: '' };
+      }
+      streamData.iframeUrl = null;
+      streamData.videoUrl = null;
+      streamData.videoSources = [];
+    }
+
+    const result = {
+      success: true,
+      data: {
+        animeId: anime?.id || null,
+        slug,
+        episode: parseInt(episode),
+        servers: streamData.servers || [],
+        selectedServer: serverId,
+        iframeUrl: streamData.iframeUrl || null,
+        videoUrl: streamData.videoUrl || null,
+        videoSources: streamData.videoSources || [],
+        credit: streamData.credit || '',
+      },
+    };
+
+    cacheSet(cacheKey, result, 7200);
+    res.json(result);
+  } catch (err) {
+    next(err);
+  }
+});
+
+// ── GET /api/search ─────────────────────────────────────
+router.get('/search', async (req, res, next) => {
+  try {
+    const { q } = req.query;
+    if (!q || q.length < 2) {
+      return res.status(400).json({ success: false, error: 'Query parameter "q" is required (min 2 chars)' });
+    }
+
+    const cacheKey = `search_${q.toLowerCase().trim()}`;
+    const cached = cacheGet(cacheKey);
+    if (cached) return res.json(cached);
+
+    // Use quicksearch AJAX endpoint for fast, accurate results
+    let data = [];
+    try {
+      const { json } = await cheerioScraper.fetchQuickSearch(q);
+      if (json.html) {
+        const $ = cheerio.load(json.html);
+        data = cheerioScraper.scrapeQuickSearchResults($);
+      }
+    } catch (quickErr) {
+      console.warn('[search] Quicksearch failed, trying page scrape:', quickErr.message);
+      // Fallback: scrape the anime list page and filter
+      try {
+        let html;
+        try {
+          const result = await cheerioScraper.fetchWithFallback(`/anime?search=${encodeURIComponent(q)}`, true);
+          html = result.html;
+        } catch {
+          const result = await cheerioScraper.fetchWithFallback(`/anime?search=${encodeURIComponent(q)}`, false);
+          html = result.html;
+        }
+        const $ = cheerio.load(html);
+        const allCards = cheerioScraper.scrapeAnimeCards($);
+        data = allCards.filter(item =>
+          item.title.toLowerCase().includes(q.toLowerCase())
+        );
+      } catch (pageErr) {
+        console.warn('[search] Page scrape also failed:', pageErr.message);
+      }
+    }
+
+    const result = {
+      success: true,
+      query: q,
+      count: data.length,
+      data,
+    };
+
+    cacheSet(cacheKey, result, 1800);
+    res.json(result);
+  } catch (err) {
+    next(err);
+  }
+});
+
+module.exports = router;

package/src/routes/status.js

@@ -0,0 +1,100 @@
+const { Router } = require('express');
+const sources = require('../config/sources');
+const { getSourceLogs, cacheGet, cacheSet } = require('../db');
+const { runSourceCheck } = require('../services/sourceUpdater');
+
+const router = Router();
+
+// ── GET /api/status ─────────────────────────────────────
+router.get('/status', async (_req, res) => {
+  const cacheKey = 'source_status';
+  const cached = cacheGet(cacheKey);
+  if (cached) return res.json(cached);
+
+  const primary = sources.getPrimary();
+  const logs = getSourceLogs(20);
+  const all = sources.getAll();
+
+  let primaryStatus = 'unknown';
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 8000);
+    const resp = await fetch(primary, {
+      headers: { 'User-Agent': 'Mozilla/5.0' },
+      signal: controller.signal,
+    });
+    clearTimeout(timer);
+    primaryStatus = resp.ok ? 'alive' : `http_${resp.status}`;
+  } catch (err) {
+    primaryStatus = err.name === 'AbortError' ? 'timeout' : 'down';
+  }
+
+  const result = {
+    success: true,
+    data: {
+      status: primaryStatus === 'alive' ? 'healthy' : 'degraded',
+      primary: {
+        url: primary,
+        status: primaryStatus,
+      },
+      alternatives: all.alternatives,
+      lastUpdated: all.lastUpdated,
+      recentLogs: logs.slice(0, 10),
+    },
+  };
+
+  cacheSet(cacheKey, result, 300);
+  res.json(result);
+});
+
+// ── GET /api/sources ────────────────────────────────────
+router.get('/sources', (_req, res) => {
+  const all = sources.getAll();
+  const urls = sources.getAllUrls();
+
+  res.json({
+    success: true,
+    data: {
+      primary: all.primary,
+      alternatives: all.alternatives,
+      allUrls: urls,
+      count: urls.length,
+      lastUpdated: all.lastUpdated,
+      updatedBy: all.updatedBy,
+    },
+  });
+});
+
+// ── POST /api/sources/check ─────────────────────────────
+router.post('/sources/check', async (_req, res) => {
+  try {
+    await runSourceCheck();
+    const all = sources.getAll();
+    res.json({
+      success: true,
+      message: 'Source health check completed',
+      data: all,
+    });
+  } catch (err) {
+    res.status(500).json({ success: false, error: err.message });
+  }
+});
+
+// ── POST /api/cache/clear ───────────────────────────────
+router.post('/cache/clear', (_req, res) => {
+  const { cacheClear } = require('../db');
+  cacheClear();
+  res.json({ success: true, message: 'Cache cleared' });
+});
+
+// ── GET /api/health ─────────────────────────────────────
+router.get('/health', (_req, res) => {
+  res.json({
+    success: true,
+    uptime: process.uptime(),
+    memory: process.memoryUsage(),
+    timestamp: new Date().toISOString(),
+  });
+});
+
+module.exports = router;

package/src/scrapers/browser.js

@@ -0,0 +1,136 @@
+/**
+ * Browser-based scraper for dynamic content (video streams).
+ * Uses browser-farm to execute JavaScript and extract iframe/video URLs.
+ */
+const browserFarm = require('../services/browserFarm');
+const sources = require('../config/sources');
+
+/**
+ * Scrape streaming URL from an episode page using a headless browser.
+ * This navigates to the episode, waits for the player to load,
+ * and extracts iframe src or video src.
+ */
+async function getStreamUrl(animeSlug, episodeNum, serverId = 'kuramadrive') {
+  const baseUrl = sources.getPrimary();
+  const episodeUrl = `${baseUrl}/anime/${animeSlug}/episode/${episodeNum}`;
+
+  // Extract the anime ID from slug or via page
+  const script = `
+    (async () => {
+      // Wait a bit for JS to load the player
+      await new Promise(r => setTimeout(r, 4000));
+
+      // Try to find iframe inside #animeVideoPlayer
+      const player = document.getElementById('animeVideoPlayer');
+      let iframeSrc = '';
+      let videoSrc = '';
+
+      if (player) {
+        const iframe = player.querySelector('iframe');
+        if (iframe) iframeSrc = iframe.src;
+
+        const video = player.querySelector('video');
+        if (video) videoSrc = video.src || video.querySelector('source')?.src || '';
+      }
+
+      // Also look for any iframe on the whole page in the player area
+      if (!iframeSrc) {
+        const allIframes = document.querySelectorAll('iframe');
+        for (const f of allIframes) {
+          const src = f.src || '';
+          if (src && !src.includes('kuramachat') && !src.includes('telegram') && !src.includes('googletagmanager')) {
+            iframeSrc = src;
+            break;
+          }
+        }
+      }
+
+      // Get the anime ID from hidden inputs
+      const currentUrl = document.getElementById('currentUrl')?.value || '';
+      const match = currentUrl.match(/\\/anime\\/(\\d+)\\//);
+      const animeId = match ? match[1] : '';
+
+      // Get server list
+      const servers = [];
+      document.querySelectorAll('#changeServer option').forEach(opt => {
+        servers.push({ id: opt.value, label: opt.textContent.trim() });
+      });
+
+      return {
+        iframeUrl: iframeSrc,
+        videoUrl: videoSrc,
+        animeId,
+        servers,
+      };
+    })()
+  `;
+
+  const result = await browserFarm.scrapeWithBrowser(episodeUrl, script, 5000);
+  return result;
+}
+
+/**
+ * Get stream URL for a specific server by changing the dropdown.
+ */
+async function getStreamWithServer(animeSlug, episodeNum, serverId) {
+  const baseUrl = sources.getPrimary();
+  const episodeUrl = `${baseUrl}/anime/${animeSlug}/episode/${episodeNum}`;
+
+  const script = `
+    (async () => {
+      // Wait for page to load
+      await new Promise(r => setTimeout(r, 3000));
+
+      // Change server if specified
+      const serverSelect = document.getElementById('changeServer');
+      if (serverSelect && '${serverId}') {
+        serverSelect.value = '${serverId}';
+        serverSelect.dispatchEvent(new Event('change', { bubbles: true }));
+        // Wait for player to reload
+        await new Promise(r => setTimeout(r, 4000));
+      }
+
+      // Try to find iframe/video
+      const player = document.getElementById('animeVideoPlayer');
+      let iframeSrc = '';
+      let videoSrc = '';
+
+      if (player) {
+        const iframe = player.querySelector('iframe');
+        if (iframe) iframeSrc = iframe.src;
+
+        const video = player.querySelector('video');
+        if (video) videoSrc = video.src || video.querySelector('source')?.src || '';
+      }
+
+      if (!iframeSrc) {
+        const allIframes = document.querySelectorAll('iframe');
+        for (const f of allIframes) {
+          const src = f.src || '';
+          if (src && !src.includes('kuramachat') && !src.includes('telegram') && !src.includes('gtag')) {
+            iframeSrc = src;
+            break;
+          }
+        }
+      }
+
+      // Get all video sources
+      const sources = [];
+      document.querySelectorAll('video source').forEach(s => {
+        sources.push({ src: s.src, type: s.type });
+      });
+
+      return {
+        iframeUrl: iframeSrc,
+        videoUrl: videoSrc,
+        videoSources: sources,
+        selectedServer: serverSelect?.value || '',
+      };
+    })()
+  `;
+
+  const result = await browserFarm.scrapeWithBrowser(episodeUrl, script, 8000);
+  return result;
+}
+
+module.exports = { getStreamUrl, getStreamWithServer };