@definisi/vidsrc-scraper 1.0.0

package/README.md

@@ -0,0 +1,73 @@
+# @definisi/vidsrc-scraper
+
+Extract HLS streaming URLs from VidSrc using TMDB ID.
+
+## Install
+
+```bash
+npm install @definisi/vidsrc-scraper
+npx playwright install firefox
+```
+
+## Usage
+
+```typescript
+import { scrapeVidsrc } from '@definisi/vidsrc-scraper';
+
+// Movie
+const movie = await scrapeVidsrc('27205');
+
+// TV Show
+const tv = await scrapeVidsrc('1396', 'tv', '1', '1');
+
+// With options
+const result = await scrapeVidsrc('27205', 'movie', null, null, {
+  timeout: 30000,
+  headless: true,
+  cacheTtl: 600,
+});
+```
+
+## API
+
+### scrapeVidsrc(tmdbId, type?, season?, episode?, options?)
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| tmdbId | string | - | TMDB ID |
+| type | 'movie' \| 'tv' | 'movie' | Content type |
+| season | string \| null | null | Season number (TV only) |
+| episode | string \| null | null | Episode number (TV only) |
+| options | ScrapeOptions | {} | Optional config |
+
+### ScrapeOptions
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| timeout | number | 60000 | Page load timeout (ms) |
+| headless | boolean | true | Run browser headless |
+| cacheTtl | number | 900 | Cache TTL (seconds) |
+
+### ScrapeResult
+
+```typescript
+{
+  tmdbId: string;
+  type: 'movie' | 'tv';
+  season: string | null;
+  episode: string | null;
+  hlsUrl: string | null;
+  subtitles: string[];
+  success: boolean;
+  timestamp: string;
+}
+```
+
+### clearCache()
+
+Clear the in-memory cache.
+
+## Requirements
+
+- Node.js 18+
+- Playwright Firefox

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { scrapeVidsrc, clearCache } from './scraper.js';
+export type { ScrapeOptions, ScrapeResult, CacheEntry } from './types.js';

package/dist/index.js

@@ -0,0 +1 @@
+export { scrapeVidsrc, clearCache } from './scraper.js';

package/dist/scraper.d.ts

@@ -0,0 +1,3 @@
+import type { ScrapeOptions, ScrapeResult } from './types.js';
+export declare function scrapeVidsrc(tmdbId: string, type?: 'movie' | 'tv', season?: string | null, episode?: string | null, options?: ScrapeOptions): Promise<ScrapeResult>;
+export declare function clearCache(): void;

package/dist/scraper.js

@@ -0,0 +1,115 @@
+import { firefox } from 'playwright';
+const DEFAULT_OPTIONS = {
+    timeout: 60000,
+    headless: true,
+    cacheTtl: 900,
+};
+const cache = new Map();
+function getCacheKey(tmdbId, type, season, episode) {
+    return `${type}-${tmdbId}-${season || ''}-${episode || ''}`;
+}
+function getFromCache(key, ttl) {
+    const cached = cache.get(key);
+    if (cached && Date.now() - cached.timestamp < ttl * 1000) {
+        return cached.data;
+    }
+    cache.delete(key);
+    return null;
+}
+function setCache(key, data) {
+    cache.set(key, { data, timestamp: Date.now() });
+}
+function buildEmbedUrl(tmdbId, type, season, episode) {
+    const base = 'https://vidsrcme.vidsrc.icu/embed';
+    if (type === 'tv') {
+        return `${base}/tv?tmdb=${tmdbId}&season=${season}&episode=${episode}&autoplay=1&ds_lang=en`;
+    }
+    return `${base}/movie?tmdb=${tmdbId}&autoplay=1&ds_lang=en`;
+}
+async function setupResponseHandler(context, result) {
+    context.on('response', async (response) => {
+        const url = response.url();
+        if (url.includes('.m3u8') && !result.hlsUrl) {
+            result.hlsUrl = url;
+        }
+        if (url.includes('.vtt') || url.includes('.srt')) {
+            result.subtitles.push(url);
+        }
+        if (url.includes('/prorcp/')) {
+            try {
+                const body = await response.text();
+                const m3u8Match = body.match(/https?:\/\/[^"'\s\\]+\.m3u8[^"'\s\\]*/);
+                if (m3u8Match && !result.hlsUrl) {
+                    result.hlsUrl = m3u8Match[0].replace(/\\/g, '');
+                }
+            }
+            catch { }
+        }
+    });
+}
+export async function scrapeVidsrc(tmdbId, type = 'movie', season = null, episode = null, options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const cacheKey = getCacheKey(tmdbId, type, season, episode);
+    const cached = getFromCache(cacheKey, opts.cacheTtl);
+    if (cached) {
+        return cached;
+    }
+    const browser = await firefox.launch({ headless: opts.headless });
+    const context = await browser.newContext({
+        userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
+        viewport: { width: 1920, height: 1080 },
+    });
+    const page = await context.newPage();
+    const responseData = { hlsUrl: null, subtitles: [] };
+    await setupResponseHandler(context, responseData);
+    try {
+        const embedUrl = buildEmbedUrl(tmdbId, type, season, episode);
+        await page.goto(embedUrl, { waitUntil: 'networkidle', timeout: opts.timeout });
+        await page.waitForTimeout(3000);
+        for (const frame of page.frames()) {
+            const frameUrl = frame.url();
+            if (frameUrl.includes('cloudnestra.com/rcp/') || frameUrl.includes('/rcp/')) {
+                try {
+                    await frame.click('#pl_but, #pl_but_background, .play-btn', { timeout: 5000 });
+                    await page.waitForTimeout(5000);
+                }
+                catch {
+                    try {
+                        await frame.evaluate(() => {
+                            if (typeof window.loadIframe === 'function') {
+                                window.loadIframe(1);
+                            }
+                        });
+                        await page.waitForTimeout(5000);
+                    }
+                    catch { }
+                }
+                break;
+            }
+        }
+        await page.waitForTimeout(3000);
+    }
+    catch (error) {
+        console.error(`[ERROR] ${error.message}`);
+    }
+    finally {
+        await browser.close();
+    }
+    const result = {
+        tmdbId,
+        type,
+        season,
+        episode,
+        hlsUrl: responseData.hlsUrl,
+        subtitles: responseData.subtitles,
+        success: !!responseData.hlsUrl,
+        timestamp: new Date().toISOString(),
+    };
+    if (result.success) {
+        setCache(cacheKey, result);
+    }
+    return result;
+}
+export function clearCache() {
+    cache.clear();
+}

package/dist/types.d.ts

@@ -0,0 +1,19 @@
+export interface ScrapeOptions {
+    timeout?: number;
+    headless?: boolean;
+    cacheTtl?: number;
+}
+export interface ScrapeResult {
+    tmdbId: string;
+    type: 'movie' | 'tv';
+    season: string | null;
+    episode: string | null;
+    hlsUrl: string | null;
+    subtitles: string[];
+    success: boolean;
+    timestamp: string;
+}
+export interface CacheEntry {
+    data: ScrapeResult;
+    timestamp: number;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@definisi/vidsrc-scraper",
+  "version": "1.0.0",
+  "description": "Extract HLS streaming URLs from VidSrc",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "vidsrc",
+    "scraper",
+    "hls",
+    "streaming",
+    "tmdb"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "playwright": "^1.40.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.5.0"
+  }
+}