Upload 15 files

index.js

@@ -0,0 +1,452 @@
+import express from 'express';
+import cors from 'cors';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import AsyncLock from 'async-lock';
+import { getDebridServices } from './src/debrids.js';
+import { isVideo, base64Encode, base64Decode, extractInfoHash } from './src/util.js';
+import { ERROR } from './src/const.js';
+import { fetchRSSFeeds as fetchIPTFeeds } from './src/iptorrents.js';
+import { fetchRSSFeeds as fetchTDayFeeds } from './src/tday.js';
+import { fetchRSSFeeds as fetchTorrentingFeeds } from './src/torrenting.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const app = express();
+const lock = new AsyncLock();
+
+app.use(cors({
+    origin: '*',
+    methods: ['GET', 'POST', 'OPTIONS'],
+    allowedHeaders: ['Content-Type', 'Authorization'],
+    credentials: true
+}));
+
+app.use(express.static(path.join(__dirname, 'public')));
+app.options('*', cors());
+
+async function getCinemetaMetadata(imdbId) {
+    try {
+        console.log(`\n🎬 Fetching Cinemeta data for ${imdbId}`);
+        const response = await fetch(`https://v3-cinemeta.strem.io/meta/movie/${imdbId}.json`);
+        if (!response.ok) throw new Error('Failed to fetch from Cinemeta');
+        const data = await response.json();
+        console.log('✅ Found:', data.meta.name);
+        return data;
+    } catch (error) {
+        console.error('❌ Cinemeta error:', error);
+        return null;
+    }
+}
+
+async function readMovieData(imdbId, year) {
+    const lockKey = `year-${year}`;
+    const yearFile = path.join(__dirname, 'movies', `${year}.json`);
+
+    try {
+        return await lock.acquire(lockKey, async () => {
+            console.log(`\n📂 Reading data for year ${year}`);
+            const content = await fs.readFile(yearFile, 'utf8');
+            const movies = JSON.parse(content);
+            const movie = movies.find(m => m.imdbId === imdbId);
+            if (movie) {
+                console.log(`✅ Found movie: ${movie.originalTitle}`);
+                console.log(`Found ${movie.streams.length} streams`);
+            }
+            return movie;
+        });
+    } catch (error) {
+        if (error.name === 'AsyncLockTimeout') {
+            console.error(`❌ Lock timeout reading year ${year}`);
+            return null;
+        }
+        if (error.code !== 'ENOENT') {
+            console.error(`❌ Error reading movie data:`, error);
+        }
+        return null;
+    }
+}
+
+async function getAllStreams(imdbId) {
+    try {
+        console.log('\n🔄 Fetching all available streams');
+        console.log('Fetching from RSS feeds for IMDB ID:', imdbId);
+
+        const startTime = Date.now();
+        const [iptStreams, tdayStreams, torrentingStreams] = await Promise.all([
+            fetchIPTFeeds(imdbId).catch(err => {
+                console.error('IPTorrents fetch failed:', err);
+                return [];
+            }),
+            fetchTDayFeeds(imdbId).catch(err => {
+                console.error('TorrentDay fetch failed:', err);
+                return [];
+            }),
+            fetchTorrentingFeeds(imdbId).catch(err => {
+                console.error('Torrenting fetch failed:', err);
+                return [];
+            })
+        ]);
+
+        console.log(`\nStream fetch results (${Date.now() - startTime}ms):`);
+        console.log('IPTorrents:', iptStreams.length, 'streams');
+        console.log('TorrentDay:', tdayStreams.length, 'streams');
+        console.log('Torrenting:', torrentingStreams.length, 'streams');
+
+        const allStreams = [
+            ...iptStreams,
+            ...tdayStreams,
+            ...torrentingStreams
+        ];
+
+        console.log('\nPre-deduplication total:', allStreams.length, 'streams');
+
+        // Remove duplicates based on infoHash
+        const uniqueStreams = Array.from(
+            new Map(
+                allStreams
+                    .filter(Boolean)
+                    .map(stream => {
+                        const hash = extractInfoHash(stream.magnetLink);
+                        return [hash, stream];
+                    })
+            ).values()
+        );
+
+        console.log('Post-deduplication total:', uniqueStreams.length, 'streams');
+
+        // Log some sample streams for debugging
+        if (uniqueStreams.length > 0) {
+            console.log('\nSample stream data:', {
+                magnetLink: uniqueStreams[0].magnetLink.substring(0, 100) + '...',
+                filename: uniqueStreams[0].filename,
+                quality: uniqueStreams[0].quality,
+                size: uniqueStreams[0].size,
+                source: uniqueStreams[0].source
+            });
+        }
+
+        return uniqueStreams;
+    } catch (error) {
+        console.error('❌ Error fetching streams:', error);
+        return [];
+    }
+}
+
+async function checkCacheStatuses(service, hashes) {
+    if (!hashes?.length) {
+        console.log('No hashes to check');
+        return {};
+    }
+
+    try {
+        console.log(`\n🔍 Checking cache status for ${hashes.length} hashes with ${service.constructor.name}`);
+        console.log('Sample hashes:', hashes.slice(0, 3));
+        
+        const startTime = Date.now();
+        const results = await service.checkCacheStatuses(hashes);
+        console.log(`Cache check completed in ${Date.now() - startTime}ms`);
+        
+        const cachedCount = Object.values(results).filter(r => r.cached).length;
+        console.log(`Cache check results: ${cachedCount} cached out of ${hashes.length} total`);
+        
+        // Log some sample results
+        const sampleHash = hashes[0];
+        if (sampleHash && results[sampleHash]) {
+            console.log('Sample cache result:', {
+                hash: sampleHash,
+                result: results[sampleHash]
+            });
+        }
+        
+        return results;
+    } catch (error) {
+        console.error('❌ Cache check error:', error);
+        return {};
+    }
+}
+
+async function mergeAndSaveStreams(existingStreams = [], newStreams = [], imdbId, year, movieTitle = '') {
+    const lockKey = `year-${year}`;
+    
+    try {
+        return await lock.acquire(lockKey, async () => {
+            if (!newStreams.length) {
+                console.log('No new streams to merge');
+                return existingStreams;
+            }
+
+            console.log(`\n🔄 Merging streams for ${movieTitle}`);
+            console.log('Existing streams:', existingStreams.length);
+            console.log('New streams:', newStreams.length);
+
+            const existingHashes = new Set(
+                existingStreams.map(stream => 
+                    extractInfoHash(stream.magnetLink)
+                ).filter(Boolean)
+            );
+
+            const uniqueNewStreams = newStreams.filter(stream => {
+                const hash = extractInfoHash(stream.magnetLink);
+                return hash && !existingHashes.has(hash);
+            });
+
+            if (!uniqueNewStreams.length) {
+                console.log('No unique new streams found');
+                return existingStreams;
+            }
+
+            console.log(`Found ${uniqueNewStreams.length} new unique streams`);
+
+            const mergedStreams = [...existingStreams, ...uniqueNewStreams];
+            const yearFile = path.join(__dirname, 'movies', `${year}.json`);
+            
+            let movies = [];
+            try {
+                const content = await fs.readFile(yearFile, 'utf8');
+                movies = JSON.parse(content);
+                console.log(`Read existing ${year}.json with ${movies.length} movies`);
+            } catch (error) {
+                console.log(`Creating new ${year}.json file`);
+            }
+            
+            const movieIndex = movies.findIndex(m => m.imdbId === imdbId);
+            if (movieIndex >= 0) {
+                console.log('Updating existing movie entry');
+                movies[movieIndex].streams = mergedStreams;
+                movies[movieIndex].lastUpdated = new Date().toISOString();
+            } else {
+                console.log('Adding new movie entry');
+                movies.push({
+                    imdbId,
+                    streams: mergedStreams,
+                    originalTitle: movieTitle,
+                    addedAt: new Date().toISOString(),
+                    lastUpdated: new Date().toISOString()
+                });
+            }
+            
+            await fs.mkdir(path.join(__dirname, 'movies'), { recursive: true });
+            
+            const tempFile = `${yearFile}.tmp`;
+            await fs.writeFile(tempFile, JSON.stringify(movies, null, 2));
+            await fs.rename(tempFile, yearFile);
+            
+            console.log(`✅ Added ${uniqueNewStreams.length} new streams to ${year}.json`);
+            return mergedStreams;
+        });
+    } catch (error) {
+        if (error.name === 'AsyncLockTimeout') {
+            console.error(`❌ Lock timeout for year ${year}, skipping save`);
+            return existingStreams;
+        }
+        console.error('❌ Error merging and saving streams:', error);
+        return existingStreams;
+    }
+}
+
+app.get('/:apiKeys/manifest.json', (req, res) => {
+    const manifest = {
+        id: 'org.multirss',
+        version: '1.0.0',
+        name: 'Multi RSS',
+        description: 'Stream movies via Debrid services',
+        resources: ['stream'],
+        types: ['movie'],
+        catalogs: []
+    };
+    res.json(manifest);
+});
+
+app.get('/:apiKeys/stream/:type/:id.json', async (req, res) => {
+    const { apiKeys, type, id } = req.params;
+    
+    try {
+        console.log('\n📡 Stream request received:', { type, id });
+        console.log('API Keys:', apiKeys);
+
+        const debridServices = getDebridServices(apiKeys);
+        if (!debridServices.length) {
+            throw new Error('No valid debrid service configured');
+        }
+
+        const metadata = await getCinemetaMetadata(id);
+        if (!metadata?.meta) return res.json({ streams: [] });
+
+        const year = new Date(metadata.meta.released).getFullYear();
+        console.log('Movie year:', year);
+
+        const movieData = await readMovieData(id, year);
+        
+        const localStreams = movieData?.streams || [];
+        console.log(`Found ${localStreams.length} streams in cache`);
+
+        let processedStreams = [];
+        
+        if (localStreams.length > 0) {
+            console.log('\n🔍 Processing cached streams');
+            const hashes = localStreams.map(stream => extractInfoHash(stream.magnetLink)).filter(Boolean);
+            console.log(`Checking ${hashes.length} hashes for cached streams`);
+
+            const cacheResults = {};
+            for (const service of debridServices) {
+                console.log(`\nChecking cache with ${service.constructor.name}`);
+                const results = await checkCacheStatuses(service, hashes);
+                Object.entries(results).forEach(([hash, info]) => {
+                    if (info.cached) cacheResults[hash] = info;
+                });
+            }
+
+            console.log(`Found ${Object.keys(cacheResults).length} cached streams`);
+
+            processedStreams = localStreams
+                .map(stream => {
+                    const hash = extractInfoHash(stream.magnetLink);
+                    const cacheInfo = cacheResults[hash];
+                    if (!cacheInfo?.cached) return null;
+                    
+                    const quality = stream.quality || stream.websiteTitle.match(/\d{3,4}p|4k|HDTS|CAM/i)?.[0] || '';
+                    const size = stream.size || stream.websiteTitle.match(/\d+(\.\d+)?\s*(GB|MB)/i)?.[0] || '';
+                    
+                    return {
+                        name: ['🧲', quality, size, `⚡️ ${cacheInfo.service}`, `[${stream.source}]`]
+                            .filter(Boolean)
+                            .join(' | '),
+                        title: stream.filename,
+                        url: `${req.protocol}://${req.get('host')}/${apiKeys}/${base64Encode(stream.magnetLink)}`,
+                        service: cacheInfo.service
+                    };
+                })
+                .filter(Boolean);
+        }
+
+        if (processedStreams.length === 0) {
+            console.log('\n🔄 No cached streams available, fetching new streams...');
+            const newStreams = await getAllStreams(id);
+            
+            if (newStreams.length > 0) {
+                await mergeAndSaveStreams(
+                    [], 
+                    newStreams, 
+                    id, 
+                    year, 
+                    metadata.meta.name
+                );
+
+                const hashes = newStreams.map(stream => extractInfoHash(stream.magnetLink)).filter(Boolean);
+                console.log(`Checking ${hashes.length} hashes for new streams`);
+
+                const cacheResults = {};
+                for (const service of debridServices) {
+                    console.log(`\nChecking cache with ${service.constructor.name}`);
+                    const results = await checkCacheStatuses(service, hashes);
+                    Object.entries(results).forEach(([hash, info]) => {
+                        if (info.cached) cacheResults[hash] = info;
+                    });
+                }
+
+                processedStreams = newStreams
+                    .map(stream => {
+                        const hash = extractInfoHash(stream.magnetLink);
+                        const cacheInfo = cacheResults[hash];
+                        if (!cacheInfo?.cached) return null;
+                        
+                        return {
+                            name: ['🧲', stream.quality, stream.size, `⚡️ ${cacheInfo.service}`, `[${stream.source}]`]
+                                .filter(Boolean)
+                                .join(' | '),
+                            title: stream.filename,
+                            url: `${req.protocol}://${req.get('host')}/${apiKeys}/${base64Encode(stream.magnetLink)}`,
+                            service: cacheInfo.service
+                        };
+                    })
+                    .filter(Boolean);
+            }
+        } else {
+            console.log('\n🔄 Starting background stream update');
+            getAllStreams(id).then(async newStreams => {
+                if (newStreams.length > 0) {
+                    console.log(`Found ${newStreams.length} new streams`);
+                    await mergeAndSaveStreams(
+                        localStreams, 
+                        newStreams, 
+                        id, 
+                        year, 
+                        metadata.meta.name
+                    );
+                }
+            }).catch(error => {
+                console.error('Background update error:', error);
+            });
+        }
+
+        processedStreams.sort((a, b) => {
+            const getQuality = name => {
+                const quality = name.match(/4k|\d{3,4}/i)?.[0]?.toLowerCase();
+                if (quality === '4k') return 2160;
+                return parseInt(quality) || 0;
+            };
+            
+            const qualityA = getQuality(a.name);
+            const qualityB = getQuality(b.name);
+            
+            return qualityB - qualityA;
+        });
+
+        console.log(`\n✅ Sending ${processedStreams.length} streams`);
+        if (processedStreams.length > 0) {
+            console.log('Sample processed stream:', {
+                name: processedStreams[0].name,
+                title: processedStreams[0].title,
+                service: processedStreams[0].service
+            });
+        }
+
+        res.json({ streams: processedStreams });
+
+    } catch (error) {
+        console.error('❌ Error processing streams:', error);
+        res.json({ streams: [] });
+    }
+});
+
+app.get('/:apiKeys/:magnetLink', async (req, res) => {
+    const { apiKeys, magnetLink } = req.params;
+    
+    try {
+        const debridServices = getDebridServices(apiKeys);
+        if (!debridServices.length) {
+            throw new Error('No valid debrid service configured');
+        }
+
+        console.log('\n🧲 Processing magnet request');
+        const decodedMagnet = base64Decode(magnetLink);
+        console.log('Decoded magnet link:', decodedMagnet.substring(0, 100) + '...');
+
+        for (const service of debridServices) {
+            try {
+                console.log(`\nTrying ${service.constructor.name}`);
+                const streamUrl = await service.getStreamUrl(decodedMagnet);
+                console.log('Stream URL generated:', streamUrl.substring(0, 100) + '...');
+                return res.redirect(streamUrl);
+            } catch (error) {
+                console.error(`Service ${service.constructor.name} failed:`, error);
+                continue;
+            }
+        }
+
+        throw new Error('All debrid services failed');
+
+    } catch (error) {
+        console.error('❌ Error processing magnet:', error);
+        res.status(500).json({ error: 'Failed to process magnet', details: error.message });
+    }
+});
+
+app.use((err, req, res, next) => {
+    console.error('\n❌ Unhandled error:', err);
+    res.status(500).json({ error: 'Internal server error', details: err.message });
+});
+
+const port = process.env.PORT || 9518;
+app.listen(port, () => console.log(`\n🚀 Addon running at http://localhost:${port}`));

package.json

@@ -0,0 +1,17 @@
+{
+  "name": "debrid-streams",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js"
+  },
+  "dependencies": {
+    "async-lock": "^1.4.0",
+    "cors": "^2.8.5",
+    "express": "^4.18.2",
+    "parse-torrent": "^11.0.17",
+    "read-torrent": "^1.3.1",
+    "xml2js": "^0.6.2"
+  }
+}

public/configure.html

@@ -0,0 +1,215 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Multi RSS Streams</title>
+    <link href="https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;700&display=swap" rel="stylesheet">
+    <style>
+        * {
+            box-sizing: border-box;
+            margin: 0;
+            padding: 0;
+        }
+        body, html {
+            height: 100%;
+            font-family: 'Roboto', sans-serif;
+            color: #ffffff;
+        }
+        body {
+            background: linear-gradient(rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7)),
+            url('/backdrop.jpg') no-repeat center center fixed;
+            background-size: cover;
+        }
+        .container {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            min-height: 100%;
+            padding: 20px;
+        }
+        .logo {
+            font-size: 3rem;
+            font-weight: 700;
+            color: #e50914;
+            margin-bottom: 2rem;
+            text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.5);
+        }
+        .content-wrapper {
+            background-color: rgba(0, 0, 0, 0.6);
+            backdrop-filter: blur(10px);
+            border-radius: 4px;
+            padding: 40px;
+            width: 100%;
+            max-width: 450px;
+            height: fit-content;
+            border: 1px solid rgba(255, 255, 255, 0.1);
+        }
+        h1 {
+            font-size: 2rem;
+            font-weight: 700;
+            margin-bottom: 28px;
+            text-align: center;
+        }
+        .input-container {
+            position: relative;
+            margin-bottom: 16px;
+        }
+        .input {
+            width: 100%;
+            height: 50px;
+            background-color: rgba(51, 51, 51, 0.8);
+            border: 1px solid rgba(255, 255, 255, 0.1);
+            border-radius: 4px;
+            color: white;
+            padding: 16px 20px 0;
+            font-size: 1rem;
+            outline: none;
+        }
+        .input:focus {
+            background-color: rgba(69, 69, 69, 0.8);
+            border-color: rgba(255, 255, 255, 0.3);
+        }
+        .input-label {
+            position: absolute;
+            top: 50%;
+            left: 20px;
+            transform: translateY(-50%);
+            transition: all 0.1s ease;
+            color: #8c8c8c;
+            pointer-events: none;
+        }
+        .input:focus + .input-label,
+        .input:not(:placeholder-shown) + .input-label {
+            top: 7px;
+            font-size: 0.7rem;
+        }
+        .btn {
+            width: 100%;
+            height: 50px;
+            background-color: #e50914;
+            color: white;
+            border: none;
+            border-radius: 4px;
+            font-size: 1rem;
+            font-weight: 700;
+            margin: 24px 0 12px;
+            cursor: pointer;
+            transition: background-color 0.2s;
+        }
+        .btn:hover {
+            background-color: #f40612;
+        }
+        .info {
+            color: #737373;
+            font-size: 0.9rem;
+            margin-top: 16px;
+            background-color: rgba(0, 0, 0, 0.6);
+            padding: 20px;
+            border-radius: 4px;
+            border: 1px solid rgba(255, 255, 255, 0.1);
+        }
+        .addon-url {
+            width: 100%;
+            background-color: rgba(51, 51, 51, 0.8);
+            color: white;
+            border: 1px solid rgba(255, 255, 255, 0.1);
+            padding: 10px;
+            margin-top: 10px;
+            border-radius: 4px;
+            word-break: break-all;
+            display: none;
+        }
+        .buttons-container {
+            display: flex;
+            gap: 10px;
+            margin-top: 10px;
+        }
+        .action-btn {
+            background-color: #e50914;
+            color: white;
+            border: none;
+            padding: 10px 20px;
+            border-radius: 4px;
+            cursor: pointer;
+            transition: background-color 0.2s;
+            flex: 1;
+            font-weight: 700;
+        }
+        .action-btn:hover {
+            background-color: #f40612;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="logo">Multi RSS</div>
+        <div class="content-wrapper">
+            <h1>Stremio Addon Installation</h1>
+            <div class="input-container">
+                <input type="text" id="dl-key" class="input" placeholder=" " required>
+                <label for="dl-key" class="input-label">DebridLink API Key</label>
+            </div>
+            <div class="input-container">
+                <input type="text" id="pr-key" class="input" placeholder=" ">
+                <label for="pr-key" class="input-label">Premiumize API Key</label>
+            </div>
+            <button class="btn" onclick="generateAddonUrl()">GENERATE</button>
+            <div id="addon-url" class="addon-url"></div>
+            <div class="info">
+                <h3>How to get API Keys:</h3>
+                <p><strong>DebridLink:</strong> Visit <a href="https://debrid-link.com/webapp/apikey" target="_blank">https://debrid-link.com/webapp/apikey</a></p>
+                <p><strong>Premiumize:</strong> Visit <a href="https://www.premiumize.me/account" target="_blank">https://www.premiumize.me/account</a></p>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        function generateAddonUrl() {
+            const dlKey = document.getElementById('dl-key').value.trim();
+            const prKey = document.getElementById('pr-key').value.trim();
+            
+            if (!dlKey && !prKey) {
+                alert('Please enter at least one API key');
+                return;
+            }
+            
+            // Get the base URL components
+            const protocol = window.location.protocol;
+            const hostname = window.location.host;
+            const baseUrl = `${protocol}//${hostname}`;
+            
+            // Generate the keys part of the URL
+            let keys = [];
+            if (dlKey) keys.push(`dl=${dlKey}`);
+            if (prKey) keys.push(`pr=${prKey}`);
+            
+            // Create the addon URL
+            const addonUrl = `${baseUrl}/${keys.join(',')}/manifest.json`;
+            
+            // Always use stremio:// protocol for the Stremio URL, regardless of original protocol
+            const stremioUrl = `stremio://${hostname}/${keys.join(',')}/manifest.json`;
+            
+            const urlDiv = document.getElementById('addon-url');
+            urlDiv.style.display = 'block';
+            urlDiv.innerHTML = `
+                <p>Your addon URL:</p>
+                <p>${addonUrl}</p>
+                <div class="buttons-container">
+                    <button onclick="window.location.href='${stremioUrl}'" class="action-btn">Install in Stremio</button>
+                    <button onclick="copyToClipboard('${addonUrl}')" class="action-btn">Copy URL</button>
+                </div>
+            `;
+        }
+
+        function copyToClipboard(text) {
+            navigator.clipboard.writeText(text).then(() => {
+                alert('URL copied to clipboard!');
+            }).catch(err => {
+                console.error('Failed to copy text: ', err);
+                alert('Failed to copy URL. Please copy it manually.');
+            });
+        }
+    </script>
+</body>
+</html>

public/index.html

@@ -0,0 +1,215 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Multi RSS Streams</title>
+    <link href="https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;700&display=swap" rel="stylesheet">
+    <style>
+        * {
+            box-sizing: border-box;
+            margin: 0;
+            padding: 0;
+        }
+        body, html {
+            height: 100%;
+            font-family: 'Roboto', sans-serif;
+            color: #ffffff;
+        }
+        body {
+            background: linear-gradient(rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7)),
+            url('/backdrop.jpg') no-repeat center center fixed;
+            background-size: cover;
+        }
+        .container {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            min-height: 100%;
+            padding: 20px;
+        }
+        .logo {
+            font-size: 3rem;
+            font-weight: 700;
+            color: #e50914;
+            margin-bottom: 2rem;
+            text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.5);
+        }
+        .content-wrapper {
+            background-color: rgba(0, 0, 0, 0.6);
+            backdrop-filter: blur(10px);
+            border-radius: 4px;
+            padding: 40px;
+            width: 100%;
+            max-width: 450px;
+            height: fit-content;
+            border: 1px solid rgba(255, 255, 255, 0.1);
+        }
+        h1 {
+            font-size: 2rem;
+            font-weight: 700;
+            margin-bottom: 28px;
+            text-align: center;
+        }
+        .input-container {
+            position: relative;
+            margin-bottom: 16px;
+        }
+        .input {
+            width: 100%;
+            height: 50px;
+            background-color: rgba(51, 51, 51, 0.8);
+            border: 1px solid rgba(255, 255, 255, 0.1);
+            border-radius: 4px;
+            color: white;
+            padding: 16px 20px 0;
+            font-size: 1rem;
+            outline: none;
+        }
+        .input:focus {
+            background-color: rgba(69, 69, 69, 0.8);
+            border-color: rgba(255, 255, 255, 0.3);
+        }
+        .input-label {
+            position: absolute;
+            top: 50%;
+            left: 20px;
+            transform: translateY(-50%);
+            transition: all 0.1s ease;
+            color: #8c8c8c;
+            pointer-events: none;
+        }
+        .input:focus + .input-label,
+        .input:not(:placeholder-shown) + .input-label {
+            top: 7px;
+            font-size: 0.7rem;
+        }
+        .btn {
+            width: 100%;
+            height: 50px;
+            background-color: #e50914;
+            color: white;
+            border: none;
+            border-radius: 4px;
+            font-size: 1rem;
+            font-weight: 700;
+            margin: 24px 0 12px;
+            cursor: pointer;
+            transition: background-color 0.2s;
+        }
+        .btn:hover {
+            background-color: #f40612;
+        }
+        .info {
+            color: #737373;
+            font-size: 0.9rem;
+            margin-top: 16px;
+            background-color: rgba(0, 0, 0, 0.6);
+            padding: 20px;
+            border-radius: 4px;
+            border: 1px solid rgba(255, 255, 255, 0.1);
+        }
+        .addon-url {
+            width: 100%;
+            background-color: rgba(51, 51, 51, 0.8);
+            color: white;
+            border: 1px solid rgba(255, 255, 255, 0.1);
+            padding: 10px;
+            margin-top: 10px;
+            border-radius: 4px;
+            word-break: break-all;
+            display: none;
+        }
+        .buttons-container {
+            display: flex;
+            gap: 10px;
+            margin-top: 10px;
+        }
+        .action-btn {
+            background-color: #e50914;
+            color: white;
+            border: none;
+            padding: 10px 20px;
+            border-radius: 4px;
+            cursor: pointer;
+            transition: background-color 0.2s;
+            flex: 1;
+            font-weight: 700;
+        }
+        .action-btn:hover {
+            background-color: #f40612;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="logo">Multi RSS</div>
+        <div class="content-wrapper">
+            <h1>Stremio Addon Installation</h1>
+            <div class="input-container">
+                <input type="text" id="dl-key" class="input" placeholder=" " required>
+                <label for="dl-key" class="input-label">DebridLink API Key</label>
+            </div>
+            <div class="input-container">
+                <input type="text" id="pr-key" class="input" placeholder=" ">
+                <label for="pr-key" class="input-label">Premiumize API Key</label>
+            </div>
+            <button class="btn" onclick="generateAddonUrl()">GENERATE</button>
+            <div id="addon-url" class="addon-url"></div>
+            <div class="info">
+                <h3>How to get API Keys:</h3>
+                <p><strong>DebridLink:</strong> Visit <a href="https://debrid-link.com/webapp/apikey" target="_blank">https://debrid-link.com/webapp/apikey</a></p>
+                <p><strong>Premiumize:</strong> Visit <a href="https://www.premiumize.me/account" target="_blank">https://www.premiumize.me/account</a></p>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        function generateAddonUrl() {
+            const dlKey = document.getElementById('dl-key').value.trim();
+            const prKey = document.getElementById('pr-key').value.trim();
+            
+            if (!dlKey && !prKey) {
+                alert('Please enter at least one API key');
+                return;
+            }
+            
+            // Get the base URL components
+            const protocol = window.location.protocol;
+            const hostname = window.location.host;
+            const baseUrl = `${protocol}//${hostname}`;
+            
+            // Generate the keys part of the URL
+            let keys = [];
+            if (dlKey) keys.push(`dl=${dlKey}`);
+            if (prKey) keys.push(`pr=${prKey}`);
+            
+            // Create the addon URL
+            const addonUrl = `${baseUrl}/${keys.join(',')}/manifest.json`;
+            
+            // Always use stremio:// protocol for the Stremio URL, regardless of original protocol
+            const stremioUrl = `stremio://${hostname}/${keys.join(',')}/manifest.json`;
+            
+            const urlDiv = document.getElementById('addon-url');
+            urlDiv.style.display = 'block';
+            urlDiv.innerHTML = `
+                <p>Your addon URL:</p>
+                <p>${addonUrl}</p>
+                <div class="buttons-container">
+                    <button onclick="window.location.href='${stremioUrl}'" class="action-btn">Install in Stremio</button>
+                    <button onclick="copyToClipboard('${addonUrl}')" class="action-btn">Copy URL</button>
+                </div>
+            `;
+        }
+
+        function copyToClipboard(text) {
+            navigator.clipboard.writeText(text).then(() => {
+                alert('URL copied to clipboard!');
+            }).catch(err => {
+                console.error('Failed to copy text: ', err);
+                alert('Failed to copy URL. Please copy it manually.');
+            });
+        }
+    </script>
+</body>
+</html>

src/aither.js

@@ -0,0 +1,142 @@
+import https from 'https';
+
+const API_CONFIG = {
+    baseUrl: 'https://aither.cc',
+    apiKey: 'dRkYjNbT0S4ObFArTH1FXUTLPGsFRV4SqpPwwwEIo0IAtzsKhfF3zkPpTpCOcyBzab5q068680zVeHPk644q9sshtqpMv5mglfou'
+};
+
+const agent = new https.Agent({
+    rejectUnauthorized: true,
+    timeout: 30000,
+    keepAlive: true
+});
+
+async function fetchWithTimeout(url, options = {}, timeout = 30000) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+    try {
+        const response = await fetch(url, {
+            ...options,
+            signal: controller.signal,
+            agent
+        });
+        clearTimeout(timeoutId);
+        return response;
+    } catch (error) {
+        clearTimeout(timeoutId);
+        throw error;
+    }
+}
+
+async function fetchTorrents(imdbId) {
+    console.log('\n🔄 Fetching from Aither API for:', imdbId);
+    try {
+        const params = new URLSearchParams({
+            imdbId: imdbId.replace('tt', ''),
+            sortField: 'created_at',
+            sortDirection: 'desc',
+            perPage: '100'
+        });
+
+        const url = `${API_CONFIG.baseUrl}/api/torrents/filter?${params}`;
+        console.log('Request URL:', url);
+
+        const response = await fetchWithTimeout(url, {
+            headers: {
+                'Host': 'aither.cc',
+                'Authorization': `Bearer ${API_CONFIG.apiKey}`,
+                'Accept': '*/*',
+                'Accept-Language': '*',
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36',
+                'Accept-Encoding': 'gzip, deflate'
+            },
+            method: 'GET',
+            compress: true
+        });
+
+        if (!response.ok) {
+            throw new Error(`API request failed: ${response.status}`);
+        }
+
+        const data = await response.json();
+
+        if (!data.data || !Array.isArray(data.data)) {
+            console.log('No torrents found');
+            return [];
+        }
+
+        console.log(`Found ${data.data.length} items`);
+        
+        const streams = await Promise.all(data.data.map(async (item, index) => {
+            try {
+                console.log(`\nProcessing item ${index + 1}/${data.data.length}:`, item.attributes.name);
+                
+                // Check if any of the files are video files
+                const hasVideoFiles = item.attributes.files.some(file => 
+                    /\.(mp4|mkv|avi|mov|wmv)$/i.test(file.name)
+                );
+
+                if (!hasVideoFiles) {
+                    console.log('No video files found in:', item.attributes.name);
+                    return null;
+                }
+
+                // Find the main video file (largest video file)
+                const videoFiles = item.attributes.files
+                    .filter(file => /\.(mp4|mkv|avi|mov|wmv)$/i.test(file.name))
+                    .sort((a, b) => b.size - a.size);
+
+                const mainFile = videoFiles[0];
+
+                return {
+                    magnetLink: `magnet:?xt=urn:btih:${item.attributes.info_hash}`,
+                    filename: mainFile.name,
+                    websiteTitle: item.attributes.name,
+                    quality: extractQuality(item.attributes.name),
+                    size: formatSize(item.attributes.size),
+                    source: 'Aither',
+                    infoHash: item.attributes.info_hash,
+                    mainFileSize: mainFile.size
+                };
+            } catch (error) {
+                console.error(`Error processing item ${index + 1}:`, error);
+                return null;
+            }
+        }));
+
+        const validStreams = streams.filter(Boolean);
+        console.log(`✅ Processed ${validStreams.length} valid streams`);
+        
+        validStreams.sort((a, b) => {
+            const qualityOrder = { '2160p': 4, '4k': 4, '1080p': 3, '720p': 2 };
+            return (qualityOrder[b.quality] || 0) - (qualityOrder[a.quality] || 0);
+        });
+
+        return validStreams;
+
+    } catch (error) {
+        console.error('❌ Error fetching from Aither:', error);
+        console.error('Error details:', {
+            message: error.message,
+            cause: error.cause,
+            code: error.code,
+            syscall: error.syscall
+        });
+        return [];
+    }
+}
+
+function extractQuality(title) {
+    const qualityMatch = title.match(/\b(2160p|1080p|720p|4k|uhd)\b/i);
+    return qualityMatch ? qualityMatch[1].toLowerCase() : '';
+}
+
+function formatSize(bytes) {
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+    if (bytes === 0) return '0 Bytes';
+    const i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)));
+    return Math.round(bytes / Math.pow(1024, i) * 100) / 100 + ' ' + sizes[i];
+}
+
+export { fetchTorrents };

src/const.js

@@ -0,0 +1,14 @@
+export const ERROR = {
+    EXPIRED_API_KEY: 'Expired API key',
+    ACCESS_DENIED: 'Access denied',
+    TWO_FACTOR_AUTH: 'Two factor authentication required',
+    NOT_PREMIUM: 'Premium account required',
+    NOT_READY: 'Torrent not ready',
+    INVALID_API_KEY: 'Invalid API key'
+};
+
+export const VIDEO_EXTENSIONS = [
+    '.mp4', '.mkv', '.avi', 
+    '.mov', '.wmv', '.flv', 
+    '.webm', '.m4v', '.ts'
+];

src/debrids.js

@@ -0,0 +1,294 @@
+import { ERROR } from './const.js';
+import { createHash } from 'crypto';
+
+class BaseDebrid {
+    #apiKey;
+    
+    constructor(apiKey, prefix) {
+        this.#apiKey = apiKey.replace(`${prefix}=`, '');
+    }
+
+    getKey() {
+        return this.#apiKey;
+    }
+}
+
+class DebridLink extends BaseDebrid {
+    constructor(apiKey) {
+        super(apiKey, 'dl');
+    }
+
+    static canHandle(apiKey) {
+        return apiKey.startsWith('dl=');
+    }
+
+    async #request(method, path, opts = {}) {
+        try {
+            const query = opts.query || {};
+            const queryString = new URLSearchParams(query).toString();
+            const url = `https://debrid-link.com/api/v2${path}${queryString ? '?' + queryString : ''}`;
+
+            opts = {
+                method,
+                headers: {
+                    'User-Agent': 'Stremio',
+                    'Accept': 'application/json',
+                    'Authorization': `Bearer ${this.getKey()}`,
+                    ...(method === 'POST' && {
+                        'Content-Type': 'application/json'
+                    }),
+                    ...(opts.headers || {})
+                },
+                ...opts
+            };
+
+            console.log('\n🔷 DebridLink Request:', method, path);
+            if (opts.body) console.log('Request Body:', opts.body);
+            console.log('Request URL:', url);
+            console.log('Request Headers:', opts.headers);
+
+            const startTime = Date.now();
+            const res = await fetch(url, opts);
+            console.log(`Response Time: ${Date.now() - startTime}ms`);
+            console.log('Response Status:', res.status);
+
+            const data = await res.json();
+            console.log('Response Data:', data);
+
+            if (!data.success) {
+                switch (data.error) {
+                    case 'badToken':
+                        throw new Error(ERROR.INVALID_API_KEY);
+                    case 'maxLink':
+                    case 'maxLinkHost':
+                    case 'maxData':
+                    case 'maxDataHost':
+                    case 'maxTorrent':
+                    case 'torrentTooBig':
+                    case 'freeServerOverload':
+                        throw new Error(ERROR.NOT_PREMIUM);
+                    default:
+                        throw new Error(`API Error: ${JSON.stringify(data)}`);
+                }
+            }
+
+            return data.value;
+
+        } catch (error) {
+            console.error('❌ Request failed:', error);
+            throw error;
+        }
+    }
+
+    async checkCacheStatuses(hashes) {
+        try {
+            console.log(`\n📡 DebridLink: Batch checking ${hashes.length} hashes`);
+            console.log('Sample hashes being checked:', hashes.slice(0, 3));
+            
+            const response = await this.#request('GET', '/seedbox/cached', {
+                query: { url: hashes.join(',') }
+            });
+            
+            console.log('Raw cache check response:', response);
+            
+            const results = {};
+            for (const hash of hashes) {
+                const cacheInfo = response[hash];
+                results[hash] = {
+                    cached: !!cacheInfo,
+                    files: cacheInfo?.files || [],
+                    fileCount: cacheInfo?.files?.length || 0,
+                    service: 'DebridLink'
+                };
+            }
+
+            const cachedCount = Object.values(results).filter(r => r.cached).length;
+            console.log(`DebridLink found ${cachedCount} cached torrents out of ${hashes.length}`);
+            
+            return results;
+        } catch (error) {
+            if (error.message === ERROR.INVALID_API_KEY) {
+                console.error('❌ Invalid DebridLink API key');
+                return {};
+            }
+            console.error('Cache check failed:', error);
+            return {};
+        }
+    }
+
+    async getStreamUrl(magnetLink) {
+        try {
+            console.log('\n📥 Using DebridLink to process magnet:', magnetLink.substring(0, 100) + '...');
+            
+            const data = await this.#request('POST', '/seedbox/add', {
+                body: JSON.stringify({
+                    url: magnetLink,
+                    async: true
+                })
+            });
+
+            console.log('Seedbox add response:', data);
+
+            const videoFiles = data.files
+                .filter(file => /\.(mp4|mkv|avi|mov|webm)$/i.test(file.name))
+                .sort((a, b) => b.size - a.size);
+
+            if (!videoFiles.length) {
+                console.error('No video files found in torrent');
+                throw new Error('No video files found');
+            }
+
+            console.log('Selected video file:', videoFiles[0].name);
+            return videoFiles[0].downloadUrl;
+        } catch (error) {
+            console.error('❌ Failed to get stream URL:', error);
+            throw error;
+        }
+    }
+}
+
+class Premiumize extends BaseDebrid {
+    #apiUrl = 'https://www.premiumize.me/api';
+
+    constructor(apiKey) {
+        super(apiKey, 'pr');
+    }
+
+    static canHandle(apiKey) {
+        return apiKey.startsWith('pr=');
+    }
+
+    async #request(method, url, opts = {}) {
+        const retries = 3;
+        let lastError;
+
+        for (let i = 0; i < retries; i++) {
+            try {
+                console.log(`\n🔷 Premiumize Request (Attempt ${i + 1}/${retries}):`, method, url);
+                if (opts.body) console.log('Request Body:', opts.body);
+
+                const controller = new AbortController();
+                const timeout = setTimeout(() => controller.abort(), 30000);
+
+                const startTime = Date.now();
+                const response = await fetch(url, {
+                    ...opts,
+                    method,
+                    signal: controller.signal
+                });
+
+                clearTimeout(timeout);
+                console.log(`Response Time: ${Date.now() - startTime}ms`);
+                console.log('Response Status:', response.status);
+
+                const data = await response.json();
+                console.log('Response Data:', data);
+                return data;
+
+            } catch (error) {
+                console.log(`Attempt ${i + 1} failed:`, error.message);
+                lastError = error;
+                if (i < retries - 1) {
+                    console.log('Retrying after 2 seconds...');
+                    await new Promise(r => setTimeout(r, 2000));
+                }
+            }
+        }
+
+        throw lastError;
+    }
+
+    async checkCacheStatuses(hashes) {
+        try {
+            console.log(`\n📡 Premiumize: Batch checking ${hashes.length} hashes`);
+            console.log('Sample hashes being checked:', hashes.slice(0, 3));
+            
+            const params = new URLSearchParams({ apikey: this.getKey() });
+            hashes.forEach(hash => params.append('items[]', hash));
+
+            const data = await this.#request('GET', `${this.#apiUrl}/cache/check?${params}`);
+            
+            if (data.status !== 'success') {
+                if (data.message === 'Invalid API key.') {
+                    console.error('❌ Invalid Premiumize API key');
+                    return {};
+                }
+                throw new Error('API Error: ' + JSON.stringify(data));
+            }
+
+            const results = {};
+            hashes.forEach((hash, index) => {
+                results[hash] = {
+                    cached: data.response[index],
+                    files: [],
+                    fileCount: 0,
+                    service: 'Premiumize'
+                };
+            });
+            
+            const cachedCount = Object.values(results).filter(r => r.cached).length;
+            console.log(`Premiumize found ${cachedCount} cached torrents out of ${hashes.length}`);
+            
+            return results;
+        } catch (error) {
+            console.error('Cache check failed:', error);
+            return {};
+        }
+    }
+
+    async getStreamUrl(magnetLink) {
+        try {
+            console.log('\n📥 Using Premiumize to process magnet:', magnetLink.substring(0, 100) + '...');
+            
+            const body = new FormData();
+            body.append('apikey', this.getKey());
+            body.append('src', magnetLink);
+
+            const data = await this.#request('POST', `${this.#apiUrl}/transfer/directdl`, {
+                body
+            });
+
+            if (data.status !== 'success') {
+                console.error('API Error:', data);
+                throw new Error('Failed to add magnet');
+            }
+
+            const videoFiles = data.content
+                .filter(file => /\.(mp4|mkv|avi|mov|webm)$/i.test(file.path))
+                .sort((a, b) => b.size - a.size);
+                
+            if (!videoFiles.length) {
+                console.error('No video files found in torrent');
+                throw new Error('No video files found');
+            }
+
+            console.log('Selected video file:', videoFiles[0].path);
+            return videoFiles[0].link;
+        } catch (error) {
+            console.error('❌ Failed to get stream URL:', error);
+            throw error;
+        }
+    }
+}
+
+export function getDebridServices(apiKeys) {
+    console.log('\n🔐 Initializing debrid services with keys:', apiKeys);
+    const services = [];
+    
+    for (const key of apiKeys.split(',')) {
+        if (DebridLink.canHandle(key)) {
+            console.log('Adding DebridLink service');
+            services.push(new DebridLink(key));
+        } else if (Premiumize.canHandle(key)) {
+            console.log('Adding Premiumize service');
+            services.push(new Premiumize(key));
+        } else {
+            console.log('Unknown service key format:', key);
+        }
+    }
+    
+    console.log(`Initialized ${services.length} debrid services`);
+    return services;
+}
+
+export { DebridLink, Premiumize };

src/iptorrents.js

@@ -0,0 +1,219 @@
+import xml2js from 'xml2js';
+import readTorrent from 'read-torrent';
+import { promisify } from 'util';
+
+const readTorrentPromise = promisify(readTorrent);
+
+const RSS_FEEDS = [
+    {
+        name: 'IPT',
+        url: 'https://ipt.beelyrics.net/t.rss?u=change;tp=change;48;20;7;100;101;62;54;77;22;99;4;78;5;66;65;23;26;55;79;25;24'
+    }
+];
+
+const parser = new xml2js.Parser({ 
+    explicitArray: false,
+    ignoreAttrs: true 
+});
+
+async function downloadAndParseTorrent(url) {
+    try {
+        console.log('Downloading torrent from:', url);
+        
+        const options = {
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+                'Accept': '*/*',
+                'Cookie': 'uid=2105434; pass=82acec029bda7c69257905656252be36; login=1',
+                'Referer': 'https://ipt.beelyrics.net/',
+                'Origin': 'https://ipt.beelyrics.net'
+            }
+        };
+
+        const torrentInfo = await readTorrentPromise(url, options);
+        console.log('Parsed torrent info:', {
+            name: torrentInfo.name,
+            length: torrentInfo.length,
+            files: torrentInfo.files?.length || 0,
+            announce: torrentInfo.announce
+        });
+
+        if (!torrentInfo?.infoHash) {
+            console.error('No info hash found');
+            return null;
+        }
+
+        const videoFiles = torrentInfo.files?.filter(file => {
+            const filePath = Array.isArray(file.path) ? file.path.join('/') : file.path;
+            return /\.(mp4|mkv|avi|mov|wmv)$/i.test(filePath);
+        }) || [];
+
+        if (videoFiles.length === 0) {
+            console.log('No video files found');
+            return null;
+        }
+
+        videoFiles.sort((a, b) => b.length - a.length);
+        const mainFile = videoFiles[0];
+        const mainFilePath = Array.isArray(mainFile.path) ? mainFile.path.join('/') : mainFile.path;
+
+        const magnetUri = `magnet:?xt=urn:btih:${torrentInfo.infoHash}` +
+                         `&dn=${encodeURIComponent(torrentInfo.name)}` +
+                         (torrentInfo.announce ? torrentInfo.announce.map(tr => `&tr=${encodeURIComponent(tr)}`).join('') : '');
+
+        return {
+            magnetLink: magnetUri,
+            files: videoFiles,
+            infoHash: torrentInfo.infoHash,
+            mainFile: {
+                path: mainFilePath,
+                length: mainFile.length
+            }
+        };
+
+    } catch (error) {
+        console.error('Error:', error);
+        return null;
+    }
+}
+
+function formatFileSize(bytes) {
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+    if (bytes === 0) return '0 Bytes';
+    const i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)));
+    return Math.round(bytes / Math.pow(1024, i) * 100) / 100 + ' ' + sizes[i];
+}
+
+function parseTorrentInfo(item) {
+    let size = 'Unknown';
+    let category = 'Unknown';
+    let sizeInMB = 0;
+
+    const parts = (item.description || '').split(/[;|]/);
+    if (parts.length >= 1) {
+        const sizeInfo = formatSize(parts[0].trim());
+        size = sizeInfo.size;
+        sizeInMB = sizeInfo.sizeInMB;
+    }
+    if (parts.length >= 2) {
+        category = parts[1].trim();
+    }
+
+    return { size, category, sizeInMB };
+}
+
+function formatSize(sizeStr) {
+    if (!sizeStr) return { size: 'Unknown', sizeInMB: 0 };
+
+    const match = sizeStr.match(/([\d.]+)\s*(GB|MB|KB|B)/i);
+    if (!match) return { size: sizeStr, sizeInMB: 0 };
+
+    const [, value, unit] = match;
+    const numValue = parseFloat(value);
+    let sizeInMB = numValue;
+
+    switch (unit.toUpperCase()) {
+        case 'GB':
+            sizeInMB *= 1024;
+            break;
+        case 'KB':
+            sizeInMB /= 1024;
+            break;
+        case 'B':
+            sizeInMB /= (1024 * 1024);
+            break;
+    }
+
+    return { 
+        size: sizeStr.trim(),
+        sizeInMB: Math.round(sizeInMB * 100) / 100
+    };
+}
+
+function extractQuality(title) {
+    const qualityMatch = title.match(/\b(2160p|1080p|720p|4k|uhd)\b/i);
+    return qualityMatch ? qualityMatch[1].toLowerCase() : '';
+}
+
+async function fetchRSSFeeds(imdbId) {
+    console.log('\n🔄 Fetching RSS feeds for:', imdbId);
+    let allStreams = [];
+
+    for (const feed of RSS_FEEDS) {
+        try {
+            console.log(`\nFetching from ${feed.name}...`);
+            
+            const rssUrl = `${feed.url};download;q=${imdbId}`;
+            
+            const response = await fetch(rssUrl, {
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+                    'Accept': 'application/rss+xml,application/xml,text/xml',
+                    'Cookie': 'uid=2105434; pass=82acec029bda7c69257905656252be36; login=1',
+                    'Referer': 'https://ipt.beelyrics.net/',
+                    'Origin': 'https://ipt.beelyrics.net'
+                }
+            });
+
+            if (!response.ok) {
+                console.error(`❌ Failed to fetch from ${feed.name}:`, response.status);
+                continue;
+            }
+
+            const rssData = await response.text();
+            const result = await parser.parseStringPromise(rssData);
+
+            if (!result?.rss?.channel?.item) {
+                console.log(`No items found in ${feed.name}`);
+                continue;
+            }
+
+            const items = Array.isArray(result.rss.channel.item) ? 
+                         result.rss.channel.item : [result.rss.channel.item];
+
+            console.log(`Found ${items.length} items in ${feed.name}`);
+            
+            const streams = await Promise.all(items.map(async (item, index) => {
+                try {
+                    console.log(`\nProcessing item ${index + 1}/${items.length}:`, item.title);
+                    
+                    const torrentInfo = await downloadAndParseTorrent(item.link);
+                    if (!torrentInfo) return null;
+
+                    const { size, category } = parseTorrentInfo(item);
+                    const quality = extractQuality(item.title);
+
+                    return {
+                        magnetLink: torrentInfo.magnetLink,
+                        filename: torrentInfo.mainFile.path,
+                        websiteTitle: item.title,
+                        quality,
+                        size,
+                        source: feed.name,
+                        infoHash: torrentInfo.infoHash,
+                        mainFileSize: torrentInfo.mainFile.length
+                    };
+                } catch (error) {
+                    console.error(`Error processing item ${index + 1}:`, error);
+                    return null;
+                }
+            }));
+
+            const validStreams = streams.filter(Boolean);
+            console.log(`✅ Processed ${validStreams.length} valid streams from ${feed.name}`);
+            allStreams = [...allStreams, ...validStreams];
+
+        } catch (error) {
+            console.error(`❌ Error fetching ${feed.name}:`, error);
+        }
+    }
+
+    allStreams.sort((a, b) => {
+        const qualityOrder = { '2160p': 4, '4k': 4, '1080p': 3, '720p': 2 };
+        return (qualityOrder[b.quality] || 0) - (qualityOrder[a.quality] || 0);
+    });
+
+    return allStreams;
+}
+
+export { fetchRSSFeeds };

src/newrss.rar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:100a6734684e1bfae4c2d0cba5e7c003e472bb2a2c88b1479b985ab922ce80ce
+size 343421

src/tday.js

@@ -0,0 +1,195 @@
+import xml2js from 'xml2js';
+import readTorrent from 'read-torrent';
+import { promisify } from 'util';
+
+const readTorrentPromise = promisify(readTorrent);
+
+const RSS_FEEDS = [
+    {
+        name: 'TD',
+        url: 'https://www.torrentday.com/t.rss?7;26;14;46;33;2;31;96;34;5;44;25;11;82;24;21;22;48;13;1;3;32;download;u=change;tp=change;change;private;do-not-share'
+    }
+];
+
+const parser = new xml2js.Parser({ 
+    explicitArray: false,
+    ignoreAttrs: true 
+});
+
+function parseTorrentInfo(item) {
+    const desc = item.description || '';
+    const match = desc.match(/Category:\s*([^]+?)Size:\s*([^]+?)$/);
+    
+    if (!match) {
+        return { size: 'Unknown', category: 'Unknown', sizeInMB: 0 };
+    }
+
+    const category = match[1].trim();
+    const size = match[2].trim();
+    
+    const sizeMatch = size.match(/([\d.]+)\s*(GB|MB|TB)/i);
+    let sizeInMB = 0;
+    
+    if (sizeMatch) {
+        const [, value, unit] = sizeMatch;
+        sizeInMB = parseFloat(value);
+        switch (unit.toUpperCase()) {
+            case 'TB':
+                sizeInMB *= 1024 * 1024;
+                break;
+            case 'GB':
+                sizeInMB *= 1024;
+                break;
+        }
+    }
+
+    return { size, category, sizeInMB };
+}
+
+async function downloadAndParseTorrent(url) {
+    try {
+        console.log('Downloading torrent from:', url);
+        
+        const options = {
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+                'Accept': '*/*',
+                'Referer': 'https://www.torrentday.com/',
+                'Origin': 'https://www.torrentday.com'
+            }
+        };
+
+        const torrentInfo = await readTorrentPromise(url, options);
+        console.log('Parsed torrent info:', {
+            name: torrentInfo.name,
+            length: torrentInfo.length,
+            files: torrentInfo.files?.length || 0
+        });
+
+        if (!torrentInfo?.infoHash) {
+            console.error('No info hash found');
+            return null;
+        }
+
+        const videoFiles = torrentInfo.files?.filter(file => {
+            const filePath = Array.isArray(file.path) ? file.path.join('/') : file.path;
+            return /\.(mp4|mkv|avi|mov|wmv)$/i.test(filePath);
+        }) || [];
+
+        if (videoFiles.length === 0) {
+            console.log('No video files found');
+            return null;
+        }
+
+        videoFiles.sort((a, b) => b.length - a.length);
+        const mainFile = videoFiles[0];
+        const mainFilePath = Array.isArray(mainFile.path) ? mainFile.path.join('/') : mainFile.path;
+
+        const magnetUri = `magnet:?xt=urn:btih:${torrentInfo.infoHash}` +
+                         `&dn=${encodeURIComponent(torrentInfo.name)}` +
+                         (torrentInfo.announce ? torrentInfo.announce.map(tr => `&tr=${encodeURIComponent(tr)}`).join('') : '');
+
+        return {
+            magnetLink: magnetUri,
+            files: videoFiles,
+            infoHash: torrentInfo.infoHash,
+            mainFile: {
+                path: mainFilePath,
+                length: mainFile.length
+            }
+        };
+
+    } catch (error) {
+        console.error('Error:', error);
+        return null;
+    }
+}
+
+async function fetchRSSFeeds(imdbId) {
+    console.log('\n🔄 Fetching RSS feeds for:', imdbId);
+    let allStreams = [];
+
+    for (const feed of RSS_FEEDS) {
+        try {
+            console.log(`\nFetching from ${feed.name}...`);
+            
+            const rssUrl = `${feed.url};q=${imdbId}`;
+            
+            const response = await fetch(rssUrl, {
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+                    'Accept': 'application/rss+xml,application/xml,text/xml',
+                    'Referer': 'https://www.torrentday.com/',
+                    'Origin': 'https://www.torrentday.com'
+                }
+            });
+
+            if (!response.ok) {
+                console.error(`❌ Failed to fetch from ${feed.name}:`, response.status);
+                continue;
+            }
+
+            const rssData = await response.text();
+            const result = await parser.parseStringPromise(rssData);
+
+            if (!result?.rss?.channel?.item) {
+                console.log(`No items found in ${feed.name}`);
+                continue;
+            }
+
+            const items = Array.isArray(result.rss.channel.item) ? 
+                         result.rss.channel.item : [result.rss.channel.item];
+
+            console.log(`Found ${items.length} items in ${feed.name}`);
+            
+            const streams = await Promise.all(items.map(async (item, index) => {
+                try {
+                    console.log(`\nProcessing item ${index + 1}/${items.length}:`, item.title);
+                    
+                    const torrentInfo = await downloadAndParseTorrent(item.link);
+                    if (!torrentInfo) return null;
+
+                    const { size, category } = parseTorrentInfo(item);
+                    const quality = extractQuality(item.title);
+
+                    return {
+                        magnetLink: torrentInfo.magnetLink,
+                        filename: torrentInfo.mainFile.path,
+                        websiteTitle: item.title,
+                        quality,
+                        size,
+                        category,
+                        source: feed.name,
+                        infoHash: torrentInfo.infoHash,
+                        mainFileSize: torrentInfo.mainFile.length,
+                        pubDate: item.pubDate
+                    };
+                } catch (error) {
+                    console.error(`Error processing item ${index + 1}:`, error);
+                    return null;
+                }
+            }));
+
+            const validStreams = streams.filter(Boolean);
+            console.log(`✅ Processed ${validStreams.length} valid streams from ${feed.name}`);
+            allStreams = [...allStreams, ...validStreams];
+
+        } catch (error) {
+            console.error(`❌ Error fetching ${feed.name}:`, error);
+        }
+    }
+
+    allStreams.sort((a, b) => {
+        const qualityOrder = { '2160p': 4, '4k': 4, 'uhd': 4, '1080p': 3, '720p': 2 };
+        return (qualityOrder[b.quality] || 0) - (qualityOrder[a.quality] || 0);
+    });
+
+    return allStreams;
+}
+
+function extractQuality(title) {
+    const qualityMatch = title.match(/\b(2160p|1080p|720p|4k|uhd)\b/i);
+    return qualityMatch ? qualityMatch[1].toLowerCase() : '';
+}
+
+export { fetchRSSFeeds };

src/test.js

@@ -0,0 +1,59 @@
+import { fetchRSSFeeds } from '../src/rss.js';
+
+async function testRSSFeeds() {
+    try {
+        // Test with a recent movie - Deadpool & Wolverine
+        const imdbId = "tt6263850";
+        console.log('\n🧪 Testing RSS Feeds with IMDB ID:', imdbId);
+
+        console.log('Fetching RSS feeds...');
+        const streams = await fetchRSSFeeds(imdbId);
+
+        console.log('\n📊 Results:');
+        console.log(`Total streams found: ${streams.length}`);
+
+        // Group streams by source
+        const sourceGroups = streams.reduce((acc, stream) => {
+            acc[stream.source] = acc[stream.source] || [];
+            acc[stream.source].push(stream);
+            return acc;
+        }, {});
+
+        // Print results by source
+        Object.entries(sourceGroups).forEach(([source, sourceStreams]) => {
+            console.log(`\n${source}:`);
+            console.log(`Found ${sourceStreams.length} streams`);
+            
+            // Print first 3 streams as examples
+            sourceStreams.slice(0, 3).forEach((stream, index) => {
+                console.log(`\n${index + 1}. Stream Details:`);
+                console.log(`Title: ${stream.filename}`);
+                console.log(`Quality: ${stream.quality}`);
+                console.log(`Size: ${stream.size}`);
+                console.log(`Magnet: ${stream.magnetLink.substring(0, 60)}...`);
+            });
+        });
+
+        // Test quality distribution
+        const qualityDistribution = streams.reduce((acc, stream) => {
+            acc[stream.quality] = (acc[stream.quality] || 0) + 1;
+            return acc;
+        }, {});
+
+        console.log('\n📈 Quality Distribution:');
+        Object.entries(qualityDistribution).forEach(([quality, count]) => {
+            console.log(`${quality}: ${count} streams`);
+        });
+
+    } catch (error) {
+        console.error('❌ Test failed:', error);
+    }
+}
+
+// Run the test
+console.log('🚀 Starting RSS Feed Test\n');
+testRSSFeeds().then(() => {
+    console.log('\n✅ Test completed');
+}).catch(error => {
+    console.error('\n❌ Test failed:', error);
+});

src/torrenting.js

@@ -0,0 +1,196 @@
+import xml2js from 'xml2js';
+import readTorrent from 'read-torrent';
+import { promisify } from 'util';
+
+const readTorrentPromise = promisify(readTorrent);
+
+const RSS_FEEDS = [
+    {
+        name: 'TT',
+        url: 'https://torrenting.com/t.rss?5;18;4;82;49;99;47;38;11;55;3;40;1;download;u=change;tp=change;change;private;do-not-share',
+        domain: 'torrenting.com'
+    }
+];
+
+const parser = new xml2js.Parser({ 
+    explicitArray: false,
+    ignoreAttrs: true 
+});
+
+function parseTorrentInfo(item) {
+    const desc = item.description || '';
+    const match = desc.match(/Category:\s*([^]+?)Size:\s*([^]+?)$/);
+    
+    if (!match) {
+        return { size: 'Unknown', category: 'Unknown', sizeInMB: 0 };
+    }
+
+    const category = match[1].trim();
+    const size = match[2].trim();
+    
+    const sizeMatch = size.match(/([\d.]+)\s*(GB|MB|TB)/i);
+    let sizeInMB = 0;
+    
+    if (sizeMatch) {
+        const [, value, unit] = sizeMatch;
+        sizeInMB = parseFloat(value);
+        switch (unit.toUpperCase()) {
+            case 'TB':
+                sizeInMB *= 1024 * 1024;
+                break;
+            case 'GB':
+                sizeInMB *= 1024;
+                break;
+        }
+    }
+
+    return { size, category, sizeInMB };
+}
+
+async function downloadAndParseTorrent(url) {
+    try {
+        console.log('Downloading torrent from:', url);
+        
+        const options = {
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+                'Accept': '*/*',
+                'Referer': 'https://torrenting.com/',
+                'Origin': 'https://torrenting.com'
+            }
+        };
+
+        const torrentInfo = await readTorrentPromise(url, options);
+        console.log('Parsed torrent info:', {
+            name: torrentInfo.name,
+            length: torrentInfo.length,
+            files: torrentInfo.files?.length || 0
+        });
+
+        if (!torrentInfo?.infoHash) {
+            console.error('No info hash found');
+            return null;
+        }
+
+        const videoFiles = torrentInfo.files?.filter(file => {
+            const filePath = Array.isArray(file.path) ? file.path.join('/') : file.path;
+            return /\.(mp4|mkv|avi|mov|wmv)$/i.test(filePath);
+        }) || [];
+
+        if (videoFiles.length === 0) {
+            console.log('No video files found');
+            return null;
+        }
+
+        videoFiles.sort((a, b) => b.length - a.length);
+        const mainFile = videoFiles[0];
+        const mainFilePath = Array.isArray(mainFile.path) ? mainFile.path.join('/') : mainFile.path;
+
+        const magnetUri = `magnet:?xt=urn:btih:${torrentInfo.infoHash}` +
+                         `&dn=${encodeURIComponent(torrentInfo.name)}` +
+                         (torrentInfo.announce ? torrentInfo.announce.map(tr => `&tr=${encodeURIComponent(tr)}`).join('') : '');
+
+        return {
+            magnetLink: magnetUri,
+            files: videoFiles,
+            infoHash: torrentInfo.infoHash,
+            mainFile: {
+                path: mainFilePath,
+                length: mainFile.length
+            }
+        };
+
+    } catch (error) {
+        console.error('Error:', error);
+        return null;
+    }
+}
+
+async function fetchRSSFeeds(imdbId) {
+    console.log('\n🔄 Fetching RSS feeds for:', imdbId);
+    let allStreams = [];
+
+    for (const feed of RSS_FEEDS) {
+        try {
+            console.log(`\nFetching from ${feed.name}...`);
+            
+            const rssUrl = `${feed.url}&q=${imdbId}`;
+            
+            const response = await fetch(rssUrl, {
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+                    'Accept': 'application/rss+xml,application/xml,text/xml',
+                    'Referer': 'https://torrenting.com/',
+                    'Origin': 'https://torrenting.com'
+                }
+            });
+
+            if (!response.ok) {
+                console.error(`❌ Failed to fetch from ${feed.name}:`, response.status);
+                continue;
+            }
+
+            const rssData = await response.text();
+            const result = await parser.parseStringPromise(rssData);
+
+            if (!result?.rss?.channel?.item) {
+                console.log(`No items found in ${feed.name}`);
+                continue;
+            }
+
+            const items = Array.isArray(result.rss.channel.item) ? 
+                         result.rss.channel.item : [result.rss.channel.item];
+
+            console.log(`Found ${items.length} items in ${feed.name}`);
+            
+            const streams = await Promise.all(items.map(async (item, index) => {
+                try {
+                    console.log(`\nProcessing item ${index + 1}/${items.length}:`, item.title);
+                    
+                    const torrentInfo = await downloadAndParseTorrent(item.link);
+                    if (!torrentInfo) return null;
+
+                    const { size, category } = parseTorrentInfo(item);
+                    const quality = extractQuality(item.title);
+
+                    return {
+                        magnetLink: torrentInfo.magnetLink,
+                        filename: torrentInfo.mainFile.path,
+                        websiteTitle: item.title,
+                        quality,
+                        size,
+                        category,
+                        source: feed.name,
+                        infoHash: torrentInfo.infoHash,
+                        mainFileSize: torrentInfo.mainFile.length,
+                        pubDate: item.pubDate
+                    };
+                } catch (error) {
+                    console.error(`Error processing item ${index + 1}:`, error);
+                    return null;
+                }
+            }));
+
+            const validStreams = streams.filter(Boolean);
+            console.log(`✅ Processed ${validStreams.length} valid streams from ${feed.name}`);
+            allStreams = [...allStreams, ...validStreams];
+
+        } catch (error) {
+            console.error(`❌ Error fetching ${feed.name}:`, error);
+        }
+    }
+
+    allStreams.sort((a, b) => {
+        const qualityOrder = { '2160p': 4, '4k': 4, 'uhd': 4, '1080p': 3, '720p': 2 };
+        return (qualityOrder[b.quality] || 0) - (qualityOrder[a.quality] || 0);
+    });
+
+    return allStreams;
+}
+
+function extractQuality(title) {
+    const qualityMatch = title.match(/\b(2160p|1080p|720p|4k|uhd)\b/i);
+    return qualityMatch ? qualityMatch[1].toLowerCase() : '';
+}
+
+export { fetchRSSFeeds };

src/util.js

@@ -0,0 +1,125 @@
+import { VIDEO_EXTENSIONS } from './const.js';
+
+export function isVideo(filename) {
+    return VIDEO_EXTENSIONS.some(ext => 
+        filename.toLowerCase().endsWith(ext)
+    );
+}
+
+export function extractInfoHash(magnetLink) {
+    const match = magnetLink.match(/xt=urn:btih:([^&]+)/i);
+    return match ? match[1].toLowerCase() : null;
+}
+
+export async function wait(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+export function base64Encode(str) {
+    return Buffer.from(str).toString('base64')
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=/g, '');
+}
+
+export function base64Decode(str) {
+    str = str.replace(/-/g, '+').replace(/_/g, '/');
+    while (str.length % 4) str += '=';
+    return Buffer.from(str, 'base64').toString('ascii');
+}
+
+export function findBestFile(files, metadata) {
+    if (!files?.length) return null;
+    if (files.length === 1) return files[0];
+
+    // If no metadata provided, return largest file
+    if (!metadata?.meta?.name) {
+        const largestFile = files.sort((a, b) => (b.size || 0) - (a.size || 0))[0];
+        console.log('Selected largest file (no metadata available):', largestFile.name || largestFile.path);
+        return largestFile;
+    }
+
+    const title = metadata.meta.name.toLowerCase();
+    const year = new Date(metadata.meta.released).getFullYear();
+    const yearStr = year.toString();
+
+    // Get key parts of the title (for Harry Potter and the Prisoner of Azkaban -> ["harry", "potter", "prisoner", "azkaban"])
+    const titleParts = title
+        .replace(/[^a-z0-9\s]/g, '')
+        .split(/\s+/)
+        .filter(part => !['and', 'the', 'of'].includes(part));
+    
+    console.log(`Looking for match with title parts:`, titleParts, `(${year})`);
+    
+    // Score each video file
+    const scoredFiles = files.map(file => {
+        let score = 0;
+        const filename = file.name?.toLowerCase() || file.path?.toLowerCase() || '';
+        
+        // Count matching title parts
+        const matchingParts = titleParts.filter(part => filename.includes(part));
+        score += (matchingParts.length / titleParts.length) * 100;
+        
+        if (matchingParts.length > 0) {
+            console.log(`Found ${matchingParts.length}/${titleParts.length} title parts in "${filename}"`);
+        }
+
+        // Year matching
+        if (filename.includes(yearStr)) {
+            score += 50;
+            console.log(`Year match found in "${filename}"`);
+        }
+
+        // Penalize likely pack/collection files
+        if (filename.match(/\b(pack|collection|complete|season|episode|[es]\d{2,3})\b/i)) {
+            score -= 30;
+            console.log(`Pack/collection penalty applied to "${filename}"`);
+        }
+
+        // Penalize extras/bonus content
+        if (filename.match(/\b(extra|bonus|behind|feature|trailer|sample)\b/i)) {
+            score -= 40;
+            console.log(`Extras/bonus penalty applied to "${filename}"`);
+        }
+
+        return { 
+            file, 
+            score, 
+            size: file.size || 0,
+            filename,
+            matchingParts
+        };
+    });
+
+    // Log all scores for debugging
+    console.log('\nFile scores:');
+    scoredFiles.forEach(({filename, score, size, matchingParts}) => {
+        console.log(`"${filename}": score=${score}, size=${(size / (1024 * 1024)).toFixed(2)}MB, matched=${matchingParts.join(', ')}`);
+    });
+
+    // Sort first by score, then by size
+    scoredFiles.sort((a, b) => {
+        // If scores are significantly different, use score
+        if (Math.abs(b.score - a.score) > 20) {
+            return b.score - a.score;
+        }
+        // If scores are close, use file size
+        return b.size - a.size;
+    });
+
+    const bestMatch = scoredFiles[0];
+    
+    // If no good matches found (low score), fall back to largest file
+    if (bestMatch.score < 30) {
+        console.log('No confident match found, falling back to largest file');
+        const largestFile = files.sort((a, b) => (b.size || 0) - (a.size || 0))[0];
+        console.log(`Selected largest file: ${largestFile.name || largestFile.path}`);
+        return largestFile;
+    }
+
+    console.log(`\nSelected "${bestMatch.file.name || bestMatch.file.path}"`);
+    console.log(`Score: ${bestMatch.score}`);
+    console.log(`Size: ${(bestMatch.size / (1024 * 1024)).toFixed(2)}MB`);
+    console.log(`Matched parts: ${bestMatch.matchingParts.join(', ')}`);
+    return bestMatch.file;
+}

src/yourbittorrent.js

@@ -0,0 +1,234 @@
+import readTorrent from 'read-torrent';
+import { promisify } from 'util';
+
+const readTorrentPromise = promisify(readTorrent);
+
+const SITE_CONFIG = {
+    baseUrl: 'https://yourbittorrent.com',
+    fallbackUrls: [
+        'https://yourbittorrent2.com'
+    ]
+};
+
+async function getCinemetaMetadata(imdbId) {
+    try {
+        console.log(`\n🎬 Fetching Cinemeta data for ${imdbId}`);
+        const response = await fetch(`https://v3-cinemeta.strem.io/meta/movie/${imdbId}.json`);
+        if (!response.ok) throw new Error('Failed to fetch from Cinemeta');
+        const data = await response.json();
+        console.log('✅ Found:', data.meta.name);
+        return data;
+    } catch (error) {
+        console.error('❌ Cinemeta error:', error);
+        return null;
+    }
+}
+
+async function fetchWithTimeout(url, options = {}, timeout = 30000) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+    try {
+        const response = await fetch(url, {
+            ...options,
+            signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        return response;
+    } catch (error) {
+        clearTimeout(timeoutId);
+        throw error;
+    }
+}
+
+async function downloadAndParseTorrent(url) {
+    try {
+        console.log('Downloading torrent from:', url);
+        
+        const options = {
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+                'Accept': '*/*',
+            }
+        };
+
+        const torrentInfo = await readTorrentPromise(url, options);
+        
+        // Check if any of the files are video files
+        const hasVideoFiles = torrentInfo.files?.some(file => {
+            const filePath = Array.isArray(file.path) ? file.path.join('/') : file.path;
+            return /\.(mp4|mkv|avi|mov|wmv)$/i.test(filePath);
+        });
+
+        if (!hasVideoFiles) {
+            console.log('No video files found');
+            return null;
+        }
+
+        // Find main video file
+        const videoFiles = torrentInfo.files.filter(file => {
+            const filePath = Array.isArray(file.path) ? file.path.join('/') : file.path;
+            return /\.(mp4|mkv|avi|mov|wmv)$/i.test(filePath);
+        }).sort((a, b) => b.length - a.length);
+
+        const mainFile = videoFiles[0];
+        const mainFilePath = Array.isArray(mainFile.path) ? mainFile.path.join('/') : mainFile.path;
+
+        const magnetUri = `magnet:?xt=urn:btih:${torrentInfo.infoHash}` +
+                       `&dn=${encodeURIComponent(torrentInfo.name)}` +
+                       (torrentInfo.announce ? torrentInfo.announce.map(tr => `&tr=${encodeURIComponent(tr)}`).join('') : '');
+
+        return {
+            magnetLink: magnetUri,
+            filename: mainFilePath,
+            torrentName: torrentInfo.name,
+            infoHash: torrentInfo.infoHash,
+            mainFileSize: mainFile.length
+        };
+
+    } catch (error) {
+        console.error('Error downloading/parsing torrent:', error);
+        return null;
+    }
+}
+
+async function searchTorrents(imdbId) {
+    console.log('\n🔄 Searching YourBittorrent for IMDB:', imdbId);
+    
+    try {
+        const metadata = await getCinemetaMetadata(imdbId);
+        if (!metadata?.meta) {
+            throw new Error('Failed to get movie metadata');
+        }
+
+        const movieName = metadata.meta.name.replace(/[&]/g, '').trim();
+        const searchQuery = `${movieName} ${new Date(metadata.meta.released).getFullYear()}`;
+        console.log('Searching for:', searchQuery);
+
+        const formattedQuery = searchQuery
+            .replace(/[\\s]+/g, '-')
+            .toLowerCase();
+
+        const url = `${SITE_CONFIG.baseUrl}/?v=&c=movies&q=${encodeURIComponent(formattedQuery)}`;
+        console.log('Request URL:', url);
+
+        const response = await fetchWithTimeout(url, {
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9',
+                'Accept-Language': 'en-US,en;q=0.9'
+            }
+        });
+
+        if (!response.ok) {
+            throw new Error(`Search request failed: ${response.status}`);
+        }
+
+        const html = await response.text();
+        const results = parseSearchResults(html);
+        console.log(`Found ${results.length} raw results`);
+
+        // Process each result through read-torrent
+        const streams = await Promise.all(results.map(async result => {
+            try {
+                if (!result.magnetLink) return null;
+                
+                const torrentInfo = await downloadAndParseTorrent(result.magnetLink);
+                if (!torrentInfo) return null;
+
+                return {
+                    magnetLink: torrentInfo.magnetLink,
+                    filename: torrentInfo.filename,
+                    websiteTitle: result.title,
+                    quality: extractQuality(result.title),
+                    size: result.size,
+                    source: 'YourBittorrent',
+                    seeders: parseInt(result.seeders) || 0,
+                    leechers: parseInt(result.leechers) || 0,
+                    mainFileSize: torrentInfo.mainFileSize
+                };
+            } catch (error) {
+                console.error('Error processing result:', error);
+                return null;
+            }
+        }));
+
+        const validStreams = streams.filter(Boolean);
+        const movieYear = new Date(metadata.meta.released).getFullYear().toString();
+        const searchTerms = movieName.toLowerCase().split(' ');
+        
+        const filteredStreams = validStreams.filter(stream => {
+            const streamTitle = stream.websiteTitle.toLowerCase();
+            const hasYear = streamTitle.includes(movieYear);
+            const hasAllTerms = searchTerms.every(term => 
+                streamTitle.includes(term.toLowerCase())
+            );
+            return hasYear && hasAllTerms;
+        });
+
+        console.log(`Found ${filteredStreams.length} relevant streams after filtering`);
+
+        filteredStreams.sort((a, b) => {
+            const qualityOrder = { '2160p': 4, '4k': 4, '1080p': 3, '720p': 2 };
+            const qualityDiff = (qualityOrder[b.quality] || 0) - (qualityOrder[a.quality] || 0);
+            if (qualityDiff === 0) {
+                return b.seeders - a.seeders;
+            }
+            return qualityDiff;
+        });
+
+        return filteredStreams;
+
+    } catch (error) {
+        console.error('❌ Error searching YourBittorrent:', error);
+        
+        for (const fallbackUrl of SITE_CONFIG.fallbackUrls) {
+            try {
+                SITE_CONFIG.baseUrl = fallbackUrl;
+                return await searchTorrents(imdbId);
+            } catch (fallbackError) {
+                console.error(`Fallback ${fallbackUrl} also failed:`, fallbackError);
+            }
+        }
+        
+        return [];
+    }
+}
+
+function parseSearchResults(html) {
+    const results = [];
+    const rows = html.match(/<tr class="table-default">[\s\S]*?<\/tr>/g) || [];
+
+    for (const row of rows) {
+        try {
+            const titleMatch = row.match(/href="\/torrent\/.*?">(.*?)<\/a>/);
+            const sizeMatch = row.match(/<td.*?>\s*([\d.]+\s*[KMGT]B)\s*<\/td>/);
+            const seedersMatch = row.match(/<td.*?>\s*(\d+)\s*<\/td>/);
+            const leechersMatch = row.match(/<td.*?>\s*(\d+)\s*<\/td>/);
+            
+            if (titleMatch) {
+                const downloadId = row.match(/\/torrent\/(\d+)\//)?.[1];
+                results.push({
+                    title: titleMatch[1],
+                    size: sizeMatch?.[1] || 'Unknown',
+                    seeders: seedersMatch?.[1] || '0',
+                    leechers: leechersMatch?.[1] || '0',
+                    magnetLink: downloadId ? 
+                        `${SITE_CONFIG.baseUrl}/down/${downloadId}.torrent` : 
+                        null
+                });
+            }
+        } catch (error) {
+            console.error('Error parsing result row:', error);
+        }
+    }
+
+    return results;
+}
+
+function extractQuality(title) {
+    const qualityMatch = title.match(/\b(2160p|1080p|720p|4k|uhd)\b/i);
+    return qualityMatch ? qualityMatch[1].toLowerCase() : '';
+}
+
+export { searchTorrents };