tor-dl 1.0.0

package/src/sources/eztv.ts

@@ -0,0 +1,70 @@
+import axios from 'axios';
+import * as cheerio from 'cheerio';
+import { TorrentResult, SourceScraper } from '../types';
+import { DEFAULT_HEADERS, TIMEOUT } from './httpClient';
+
+export class EZTvScraper implements SourceScraper {
+  name = 'EZTV';
+
+  async search(query: string, category?: string): Promise<TorrentResult[]> {
+    try {
+      const url = `https://eztv.io/search/${encodeURIComponent(query)}`;
+      const { data } = await axios.get(url, {
+        headers: DEFAULT_HEADERS,
+        timeout: TIMEOUT
+      });
+      
+      const $ = cheerio.load(data);
+      const results: TorrentResult[] = [];
+      
+      $('tr.forum_topic_border, tr.forum_topic').each((i, el) => {
+        const title = $(el).find('td.forum_topic_header a').text().trim() || 
+                      $(el).find('td:nth-child(2) a').text().trim();
+        const size = $(el).find('td:nth-child(4)').text().trim();
+        const seeds = parseInt($(el).find('td:nth-child(5)').text().trim()) || 0;
+        const peers = parseInt($(el).find('td:nth-child(6)').text().trim()) || 0;
+        const url = 'https://eztv.io' + ($(el).find('td:nth-child(2) a').attr('href') || '');
+        const magnet = $(el).find('a[href^="magnet:"]').attr('href');
+        
+        if (title) {
+          results.push({
+            num: results.length + 1,
+            name: title,
+            size: size || 'Unknown',
+            sizeBytes: this.parseSize(size),
+            seeds,
+            peers,
+            source: 'EZTV',
+            url,
+            magnet
+          });
+        }
+      });
+      
+      return results;
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      console.error(`EZTV search error: ${message}`);
+      return [];
+    }
+  }
+
+  async getTorrentUrl(result: TorrentResult): Promise<string> {
+    return result.url;
+  }
+
+  async getMagnet(result: TorrentResult): Promise<string> {
+    return result.magnet || '';
+  }
+
+  private parseSize(size: string): number {
+    const match = size.match(/([\d.]+)\s*(GB|MB|TB|KB)/i);
+    if (!match) return 0;
+    const value = parseFloat(match[1]);
+    const unit = match[2].toUpperCase();
+    const multipliers: Record<string, number> = { 'KB': 1024, 'MB': 1024**2, 'GB': 1024**3, 'TB': 1024**4 };
+    return value * (multipliers[unit] || 1);
+  }
+}
+
+export default new EZTvScraper();

package/src/sources/httpClient.ts

@@ -0,0 +1,39 @@
+import axios from 'axios';
+
+const USER_AGENTS = [
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
+  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36',
+  'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+];
+
+function getRandomUserAgent(): string {
+  return USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)];
+}
+
+export function getHeaders() {
+  return {
+    'User-Agent': getRandomUserAgent(),
+    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+    'Accept-Language': 'en-US,en;q=0.5',
+    'Accept-Encoding': 'gzip, deflate',
+    'Connection': 'keep-alive',
+    'Upgrade-Insecure-Requests': '1',
+    'Cache-Control': 'max-age=0',
+    'Referer': 'https://www.google.com/'
+  };
+}
+
+export const DEFAULT_HEADERS = getHeaders();
+export const TIMEOUT = 20000;
+
+export function createAxiosInstance() {
+  return axios.create({
+    headers: getHeaders(),
+    timeout: TIMEOUT,
+    maxRedirects: 5
+  });
+}
+
+export const http = createAxiosInstance();

package/src/sources/limetorrent.ts

@@ -0,0 +1,78 @@
+import axios from 'axios';
+import * as cheerio from 'cheerio';
+import { TorrentResult, SourceScraper } from '../types';
+import { DEFAULT_HEADERS, TIMEOUT } from './httpClient';
+
+export class LimetorrentsScraper implements SourceScraper {
+  name = 'Limetorrents';
+
+  async search(query: string, category?: string): Promise<TorrentResult[]> {
+    try {
+      const catMap: Record<string, string> = { movie: 'movies', tv: 'tv', music: 'music', games: 'games', apps: 'applications' };
+      const catParam = category && catMap[category] ? `/${catMap[category]}` : '';
+      const url = `https://www.limetorrent.eu/search${catParam}/${encodeURIComponent(query)}`;
+      
+      const { data } = await axios.get(url, {
+        headers: DEFAULT_HEADERS,
+        timeout: TIMEOUT
+      });
+      
+      const $ = cheerio.load(data);
+      const results: TorrentResult[] = [];
+      
+      $('table.table2 tr').each((i, el) => {
+        const title = $(el).find('td:nth-child(1) a').text().trim();
+        const size = $(el).find('td:nth-child(2)').text().trim();
+        const seeds = parseInt($(el).find('td:nth-child(3)').text().trim()) || 0;
+        const peers = parseInt($(el).find('td:nth-child(4)').text().trim()) || 0;
+        const link = $(el).find('td:nth-child(1) a').attr('href') || '';
+        
+        if (title && !title.includes(' Torrent')) {
+          results.push({
+            num: results.length + 1,
+            name: title,
+            size: size || 'Unknown',
+            sizeBytes: this.parseSize(size),
+            seeds,
+            peers,
+            source: 'Limetorrents',
+            url: link.startsWith('http') ? link : `https://www.limetorrent.eu${link}`,
+            magnet: ''
+          });
+        }
+      });
+      
+      return results;
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      console.error(`Limetorrents search error: ${message}`);
+      return [];
+    }
+  }
+
+  async getTorrentUrl(result: TorrentResult): Promise<string> {
+    return result.url;
+  }
+
+  async getMagnet(result: TorrentResult): Promise<string> {
+    try {
+      const { data } = await axios.get(result.url, { headers: DEFAULT_HEADERS, timeout: TIMEOUT });
+      const $ = cheerio.load(data);
+      return $('a[href^="magnet:"]').attr('href') || '';
+    } catch {
+      return '';
+    }
+  }
+
+  private parseSize(size: string): number {
+    if (!size) return 0;
+    const match = size.toString().match(/([\d.]+)\s*(GB|MB|TB|KB)/i);
+    if (!match) return 0;
+    const value = parseFloat(match[1]);
+    const unit = match[2].toUpperCase();
+    const multipliers: Record<string, number> = { 'KB': 1024, 'MB': 1024**2, 'GB': 1024**3, 'TB': 1024**4 };
+    return value * (multipliers[unit] || 1);
+  }
+}
+
+export default new LimetorrentsScraper();

package/src/sources/nyaa.ts

@@ -0,0 +1,85 @@
+import axios from 'axios';
+import * as cheerio from 'cheerio';
+import { TorrentResult, SourceScraper } from '../types';
+import { DEFAULT_HEADERS, TIMEOUT } from './httpClient';
+
+export class NyaaScraper implements SourceScraper {
+  name = 'Nyaa';
+
+  async search(query: string, category?: string): Promise<TorrentResult[]> {
+    try {
+      const catMap: Record<string, string> = {
+        movie: '0_0',
+        tv: '0_0',
+        anime: '1_2',
+        music: '2_0',
+        games: '3_0',
+        apps: '4_0'
+      };
+      const cat = category && catMap[category] ? catMap[category] : '0_0';
+      const url = `https://nyaa.si/?q=${encodeURIComponent(query)}&c=${cat}`;
+      
+      const { data } = await axios.get(url, {
+        headers: DEFAULT_HEADERS,
+        timeout: TIMEOUT
+      });
+      
+      const $ = cheerio.load(data);
+      const results: TorrentResult[] = [];
+      
+      $('table tbody tr').each((i, el) => {
+        const titleEl = $(el).find('td:nth-child(2) a');
+        const title = titleEl.text().trim();
+        const link = 'https://nyaa.si' + (titleEl.attr('href') || '');
+        const size = $(el).find('td:nth-child(4)').text().trim();
+        const seeds = parseInt($(el).find('td:nth-child(6)').text().trim()) || 0;
+        const peers = parseInt($(el).find('td:nth-child(7)').text().trim()) || 0;
+        
+        if (title && title.length > 3) {
+          results.push({
+            num: results.length + 1,
+            name: title,
+            size: size || 'Unknown',
+            sizeBytes: this.parseSize(size),
+            seeds,
+            peers,
+            source: 'Nyaa',
+            url: link,
+            magnet: ''
+          });
+        }
+      });
+      
+      return results.slice(0, 50);
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      console.error(`Nyaa search error: ${message}`);
+      return [];
+    }
+  }
+
+  async getTorrentUrl(result: TorrentResult): Promise<string> {
+    return result.url;
+  }
+
+  async getMagnet(result: TorrentResult): Promise<string> {
+    try {
+      const { data } = await axios.get(result.url, { headers: DEFAULT_HEADERS, timeout: TIMEOUT });
+      const $ = cheerio.load(data);
+      return $('a[href^="magnet:"]').attr('href') || '';
+    } catch {
+      return '';
+    }
+  }
+
+  private parseSize(size: string): number {
+    const match = size.toString().match(/([\d.]+)\s*(GB|MB|TB|KB|GiB|MiB|TiB|KiB)/i);
+    if (!match) return 0;
+    const value = parseFloat(match[1]);
+    const unit = match[2].toUpperCase().replace('I', '');
+    const multipliers: Record<string, number> = { 'KB': 1024, 'MB': 1024**2, 'GB': 1024**3, 'TB': 1024**4 };
+    return value * (multipliers[unit] || 1);
+  }
+}
+
+export default new NyaaScraper();

package/src/sources/rarbg.ts

@@ -0,0 +1,86 @@
+import axios from 'axios';
+import * as cheerio from 'cheerio';
+import { TorrentResult, SourceScraper } from '../types';
+import { DEFAULT_HEADERS, TIMEOUT } from './httpClient';
+
+export class RarBGScraper implements SourceScraper {
+  name = 'RarBG';
+
+  async search(query: string, category?: string): Promise<TorrentResult[]> {
+    try {
+      const catMap: Record<string, string> = { movie: '4', tv: '14' };
+      const catParam = category && catMap[category] ? `&category=${catMap[category]}` : '';
+      const url = `https://rarbg.to/torrents.php?search=${encodeURIComponent(query)}${catParam}`;
+      
+      const { data } = await axios.get(url, {
+        headers: DEFAULT_HEADERS,
+        timeout: TIMEOUT
+      });
+      
+      const $ = cheerio.load(data);
+      const results: TorrentResult[] = [];
+      
+      $('table.lista2 tr').each((i, el) => {
+        const titleEl = $(el).find('td:nth-child(2) a');
+        const title = titleEl.text().trim();
+        const size = $(el).find('td:nth-child(4)').text().trim();
+        const seeds = parseInt($(el).find('td:nth-child(5)').text().trim()) || 0;
+        const peers = parseInt($(el).find('td:nth-child(6)').text().trim()) || 0;
+        const link = 'https://rarbg.to' + (titleEl.attr('href') || '');
+        
+        if (title && !title.includes('imdb') && !title.includes('tvcache')) {
+          results.push({
+            num: results.length + 1,
+            name: title,
+            size: size || 'Unknown',
+            sizeBytes: this.parseSize(size),
+            seeds,
+            peers,
+            source: 'RarBG',
+            url: link,
+            magnet: ''
+          });
+        }
+      });
+      
+      return results;
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      console.error(`RarBG search error: ${message}`);
+      return [];
+    }
+  }
+
+  async getTorrentUrl(result: TorrentResult): Promise<string> {
+    try {
+      const { data } = await axios.get(result.url, { headers: DEFAULT_HEADERS, timeout: TIMEOUT });
+      const $ = cheerio.load(data);
+      const torrentUrl = $('a[href$=".torrent"]').attr('href');
+      return torrentUrl || '';
+    } catch {
+      return '';
+    }
+  }
+
+  async getMagnet(result: TorrentResult): Promise<string> {
+    try {
+      const { data } = await axios.get(result.url, { headers: DEFAULT_HEADERS, timeout: TIMEOUT });
+      const $ = cheerio.load(data);
+      return $('a[href^="magnet:"]').attr('href') || '';
+    } catch {
+      return '';
+    }
+  }
+
+  private parseSize(size: string): number {
+    if (!size) return 0;
+    const match = size.toString().match(/([\d.]+)\s*(GB|MB|TB|KB)/i);
+    if (!match) return 0;
+    const value = parseFloat(match[1]);
+    const unit = match[2].toUpperCase();
+    const multipliers: Record<string, number> = { 'KB': 1024, 'MB': 1024**2, 'GB': 1024**3, 'TB': 1024**4 };
+    return value * (multipliers[unit] || 1);
+  }
+}
+
+export default new RarBGScraper();

package/src/sources/registry.ts

@@ -0,0 +1,70 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { SourcesJSON, SourceConfig, SourceScraper } from '../types';
+
+import eztv from './eztv';
+import solidtorrents from './solidtorrents';
+import thepiratebay from './thepiratebay';
+import torlock from './torlock';
+import torrentproject from './torrentproject';
+import torrentscsv from './torrentscsv';
+import limetorrent from './limetorrent';
+import _1337x from './1337x';
+import rarbg from './rarbg';
+import yts from './yts';
+import nyaa from './nyaa';
+
+const scrapers: Record<string, SourceScraper> = {
+  eztv,
+  solidtorrents,
+  thepiratebay,
+  torlock,
+  torrentproject,
+  torrentscsv,
+  limetorrent,
+  '1337x': _1337x,
+  rarbg,
+  yts,
+  nyaa
+};
+
+export function loadSourcesConfig(): SourcesJSON {
+  const sourcesPath = join(process.cwd(), 'sources.json');
+  if (existsSync(sourcesPath)) {
+    return JSON.parse(readFileSync(sourcesPath, 'utf-8'));
+  }
+  return { updateUrl: '', version: '1.0.0', sources: {} };
+}
+
+export function getEnabledSources(): SourceScraper[] {
+  const config = loadSourcesConfig();
+  const enabled: SourceScraper[] = [];
+  
+  for (const [key, sourceConfig] of Object.entries(config.sources)) {
+    if (sourceConfig.enabled && scrapers[key]) {
+      enabled.push(scrapers[key]);
+    }
+  }
+  
+  if (enabled.length === 0) {
+    return Object.values(scrapers);
+  }
+  
+  return enabled;
+}
+
+export function getSourceConfig(name: string): SourceConfig | undefined {
+  const config = loadSourcesConfig();
+  return config.sources[name];
+}
+
+export function getUpdateUrl(): string {
+  const config = loadSourcesConfig();
+  return config.updateUrl;
+}
+
+export function getAllScrapers(): Record<string, SourceScraper> {
+  return scrapers;
+}
+
+export { scrapers };

package/src/sources/solidtorrents.ts

@@ -0,0 +1,70 @@
+import axios from 'axios';
+import * as cheerio from 'cheerio';
+import { TorrentResult, SourceScraper } from '../types';
+import { DEFAULT_HEADERS, TIMEOUT } from './httpClient';
+
+export class SolidTorrentsScraper implements SourceScraper {
+  name = 'SolidTorrents';
+
+  async search(query: string, category?: string): Promise<TorrentResult[]> {
+    try {
+      const url = `https://solidtorrents.to/search?q=${encodeURIComponent(query)}`;
+      const { data } = await axios.get(url, {
+        headers: DEFAULT_HEADERS,
+        timeout: TIMEOUT
+      });
+      
+      const $ = cheerio.load(data);
+      const results: TorrentResult[] = [];
+      
+      $('div[data-href^="/torrent/"]').each((i, el) => {
+        const title = $(el).find('a.torrent-title').text().trim();
+        const size = $(el).find('span[data-size]').attr('data-size') || 'Unknown';
+        const seeds = parseInt($(el).find('span.seed-count').text().trim()) || 0;
+        const peers = parseInt($(el).find('span.leech-count').text().trim()) || 0;
+        const link = 'https://solidtorrents.to' + $(el).find('a.torrent-title').attr('href');
+        const magnet = $(el).find('a[href^="magnet:"]').attr('href');
+        
+        if (title) {
+          results.push({
+            num: results.length + 1,
+            name: title,
+            size,
+            sizeBytes: this.parseSize(size),
+            seeds,
+            peers,
+            source: 'SolidTorrents',
+            url: link,
+            magnet
+          });
+        }
+      });
+      
+      return results;
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      console.error(`SolidTorrents search error: ${message}`);
+      return [];
+    }
+  }
+
+  async getTorrentUrl(result: TorrentResult): Promise<string> {
+    return result.url;
+  }
+
+  async getMagnet(result: TorrentResult): Promise<string> {
+    return result.magnet || '';
+  }
+
+  private parseSize(size: string): number {
+    if (!size || size === 'Unknown') return 0;
+    const match = size.toString().match(/([\d.]+)\s*(GB|MB|TB|KB)/i);
+    if (!match) return 0;
+    const value = parseFloat(match[1]);
+    const unit = match[2].toUpperCase();
+    const multipliers: Record<string, number> = { 'KB': 1024, 'MB': 1024**2, 'GB': 1024**3, 'TB': 1024**4 };
+    return value * (multipliers[unit] || 1);
+  }
+}
+
+export default new SolidTorrentsScraper();

package/src/sources/thepiratebay.ts

@@ -0,0 +1,65 @@
+import axios from 'axios';
+import { TorrentResult, SourceScraper } from '../types';
+import { DEFAULT_HEADERS, TIMEOUT } from './httpClient';
+
+const API_URL = 'https://apibay.org/q.php';
+
+const CAT_MAP: Record<string, string> = { movie: '201', tv: '205', music: '102', games: '400', apps: '300' };
+
+export class ThePirateBayScraper implements SourceScraper {
+  name = 'ThePirateBay';
+
+  async search(query: string, category?: string): Promise<TorrentResult[]> {
+    try {
+      const cat = category && CAT_MAP[category] ? CAT_MAP[category] : '0';
+      const url = `${API_URL}?q=${encodeURIComponent(query)}&cat=${cat}&limit=100`;
+      
+      const { data } = await axios.get(url, {
+        headers: DEFAULT_HEADERS,
+        timeout: TIMEOUT
+      });
+      
+      if (!Array.isArray(data)) return [];
+      
+      const results: TorrentResult[] = data.slice(0, 50).map((item: any) => ({
+        num: 0,
+        name: item.name,
+        size: this.formatSize(parseInt(item.size)),
+        sizeBytes: parseInt(item.size),
+        seeds: parseInt(item.seeders) || 0,
+        peers: parseInt(item.leechers) || 0,
+        source: 'ThePirateBay',
+        url: `https://thepiratebay.org/torrent/${item.id}`,
+        magnet: `magnet:?xt=urn:btih:${item.info_hash}`,
+        hash: item.info_hash
+      }));
+      
+      results.forEach((r, i) => r.num = i + 1);
+      return results;
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      console.error(`ThePirateBay search error: ${message}`);
+      return [];
+    }
+  }
+
+  async getTorrentUrl(result: TorrentResult): Promise<string> {
+    return result.url;
+  }
+
+  async getMagnet(result: TorrentResult): Promise<string> {
+    return result.magnet || '';
+  }
+
+  private formatSize(bytes: number): string {
+    const gb = bytes / (1024**3);
+    if (gb >= 1) return `${gb.toFixed(2)} GB`;
+    const mb = bytes / (1024**2);
+    if (mb >= 1) return `${mb.toFixed(2)} MB`;
+    const kb = bytes / 1024;
+    if (kb >= 1) return `${kb.toFixed(2)} KB`;
+    return `${bytes} B`;
+  }
+}
+
+export default new ThePirateBayScraper();

package/src/sources/torlock.ts

@@ -0,0 +1,82 @@
+import axios from 'axios';
+import * as cheerio from 'cheerio';
+import { TorrentResult, SourceScraper } from '../types';
+import { DEFAULT_HEADERS, TIMEOUT } from './httpClient';
+
+const AD_KEYWORDS = ['vpn', 'service', 'banner', 'advertisement', 'sponsored', 'aclib', 'zoneid'];
+
+function isAdContent(title: string): boolean {
+  const lower = title.toLowerCase();
+  return AD_KEYWORDS.some(keyword => lower.includes(keyword));
+}
+
+export class TorLockScraper implements SourceScraper {
+  name = 'TorLock';
+
+  async search(query: string, category?: string): Promise<TorrentResult[]> {
+    try {
+      const url = `https://www.torlock.com/all/torrents/${encodeURIComponent(query)}.html`;
+      const { data } = await axios.get(url, {
+        headers: DEFAULT_HEADERS,
+        timeout: TIMEOUT
+      });
+      
+      const $ = cheerio.load(data);
+      const results: TorrentResult[] = [];
+      
+      $('table tbody tr').each((i, el) => {
+        const title = $(el).find('td:nth-child(2) a').text().trim();
+        const size = $(el).find('td:nth-child(3)').text().trim();
+        const seeds = parseInt($(el).find('td:nth-child(4)').text().trim()) || 0;
+        const peers = parseInt($(el).find('td:nth-child(5)').text().trim()) || 0;
+        const link = 'https://www.torlock.com' + ($(el).find('td:nth-child(2) a').attr('href') || '');
+        
+        if (title && !isAdContent(title)) {
+          results.push({
+            num: results.length + 1,
+            name: title,
+            size: size || 'Unknown',
+            sizeBytes: this.parseSize(size),
+            seeds,
+            peers,
+            source: 'TorLock',
+            url: link,
+            magnet: ''
+          });
+        }
+      });
+      
+      return results;
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      console.error(`TorLock search error: ${message}`);
+      return [];
+    }
+  }
+
+  async getTorrentUrl(result: TorrentResult): Promise<string> {
+    return result.url;
+  }
+
+  async getMagnet(result: TorrentResult): Promise<string> {
+    try {
+      const { data } = await axios.get(result.url, { headers: DEFAULT_HEADERS, timeout: TIMEOUT });
+      const $ = cheerio.load(data);
+      return $('a[href^="magnet:"]').attr('href') || '';
+    } catch {
+      return '';
+    }
+  }
+
+  private parseSize(size: string): number {
+    if (!size) return 0;
+    const match = size.toString().match(/([\d.]+)\s*(GB|MB|TB|KB)/i);
+    if (!match) return 0;
+    const value = parseFloat(match[1]);
+    const unit = match[2].toUpperCase();
+    const multipliers: Record<string, number> = { 'KB': 1024, 'MB': 1024**2, 'GB': 1024**3, 'TB': 1024**4 };
+    return value * (multipliers[unit] || 1);
+  }
+}
+
+export default new TorLockScraper();