tor-dl 1.0.0

package/src/sources/torrentproject.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 TorrentProjectScraper implements SourceScraper {
+  name = 'TorrentProject';
+
+  async search(query: string, category?: string): Promise<TorrentResult[]> {
+    try {
+      const url = `https://torrentproject.site/?s=${encodeURIComponent(query)}&p=1`;
+      const { data } = await axios.get(url, {
+        headers: DEFAULT_HEADERS,
+        timeout: TIMEOUT
+      });
+      
+      const $ = cheerio.load(data);
+      const results: TorrentResult[] = [];
+      
+      $('div.torrent_row, div.torrents__torrent').each((i, el) => {
+        const title = $(el).find('a.title').text().trim() || $(el).find('a').first().text().trim();
+        const size = $(el).find('span.size, div.size').text().trim();
+        const seeds = parseInt($(el).find('span.seeders, div.seeds').text().trim()) || 0;
+        const peers = parseInt($(el).find('span.leechers, div.leechs').text().trim()) || 0;
+        const link = $(el).find('a.title').attr('href') || $(el).find('a').first().attr('href') || '';
+        const magnet = $(el).find('a[href^="magnet:"]').attr('href');
+        
+        if (title && link) {
+          results.push({
+            num: results.length + 1,
+            name: title,
+            size: size || 'Unknown',
+            sizeBytes: this.parseSize(size),
+            seeds,
+            peers,
+            source: 'TorrentProject',
+            url: link.startsWith('http') ? link : `https://torrentproject.site${link}`,
+            magnet
+          });
+        }
+      });
+      
+      return results;
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      console.error(`TorrentProject 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) 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 TorrentProjectScraper();

package/src/sources/torrentscsv.ts

@@ -0,0 +1,58 @@
+import axios from 'axios';
+import { TorrentResult, SourceScraper } from '../types';
+import { DEFAULT_HEADERS, TIMEOUT } from './httpClient';
+
+export class TorrentsCsvScraper implements SourceScraper {
+  name = 'torrents-csv';
+
+  async search(query: string, category?: string): Promise<TorrentResult[]> {
+    try {
+      const url = `https://torrents-csv.ml/api/search?q=${encodeURIComponent(query)}`;
+      const { data } = await axios.get(url, {
+        headers: DEFAULT_HEADERS,
+        timeout: TIMEOUT
+      });
+      
+      const results: TorrentResult[] = [];
+      const torrents = Array.isArray(data) ? data : data.torrents || [];
+      
+      for (const t of torrents.slice(0, 50)) {
+        results.push({
+          num: results.length + 1,
+          name: t.name || t.title || 'Unknown',
+          size: this.formatSize(t.length || t.size || 0),
+          sizeBytes: t.length || t.size || 0,
+          seeds: t.seeders || t.s || 0,
+          peers: t.leechers || t.l || 0,
+          source: 'torrents-csv',
+          url: t.link || t.info_hash ? `magnet:?xt=urn:btih:${t.info_hash}` : '',
+          magnet: t.link || t.magnet ? `magnet:?xt=urn:btih:${t.info_hash}` : '',
+          hash: t.info_hash
+        });
+      }
+      
+      return results;
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      console.error(`torrents-csv search error: ${message}`);
+      return [];
+    }
+  }
+
+  async getTorrentUrl(result: TorrentResult): Promise<string> {
+    return result.url;
+  }
+
+  async getMagnet(result: TorrentResult): Promise<string> {
+    return result.magnet || `magnet:?xt=urn:btih:${result.hash}`;
+  }
+
+  private formatSize(bytes: number): string {
+    if (bytes < 1024) return bytes + ' B';
+    if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(2) + ' KB';
+    if (bytes < 1024 * 1024 * 1024) return (bytes / (1024 * 1024)).toFixed(2) + ' MB';
+    return (bytes / (1024 * 1024 * 1024)).toFixed(2) + ' GB';
+  }
+}
+
+export default new TorrentsCsvScraper();

package/src/sources/yts.ts

@@ -0,0 +1,85 @@
+import axios from 'axios';
+import * as cheerio from 'cheerio';
+import { TorrentResult, SourceScraper } from '../types';
+import { getHeaders, TIMEOUT } from './httpClient';
+
+export class YtsScraper implements SourceScraper {
+  name = 'YTS';
+
+  async search(query: string, category?: string): Promise<TorrentResult[]> {
+    if (category && category.toLowerCase() === 'tv') {
+      return [];
+    }
+
+    try {
+      const url = `https://yts.lt/api/v2/list_movies.json?query_term=${encodeURIComponent(query)}&limit=50`;
+      const { data } = await axios.get(url, {
+        headers: getHeaders(),
+        timeout: TIMEOUT
+      });
+
+      const results: TorrentResult[] = [];
+
+      if (data.data && data.data.movies) {
+        for (const movie of data.data.movies) {
+          const quality = movie.torrents?.[0]?.quality || 'Unknown';
+          const sizeStr = movie.torrents?.[0]?.size || '0';
+          const sizeBytes = this.parseSizeStr(sizeStr);
+          results.push({
+            num: results.length + 1,
+            name: `${movie.title} (${movie.year}) ${quality}`,
+            size: this.formatSize(sizeBytes),
+            sizeBytes: sizeBytes,
+            seeds: movie.torrents?.[0]?.seeds || 0,
+            peers: movie.torrents?.[0]?.peers || 0,
+            source: 'YTS',
+            url: movie.torrents?.[0]?.url || '',
+            magnet: movie.torrents?.[0]?.hash ? `magnet:?xt=urn:btih:${movie.torrents[0].hash}` : '',
+            hash: movie.torrents?.[0]?.hash
+          });
+        }
+      }
+
+      return results;
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      console.error(`YTS search error: ${message}`);
+      return [];
+    }
+  }
+
+  async getTorrentUrl(result: TorrentResult): Promise<string> {
+    return result.url;
+  }
+
+  async getMagnet(result: TorrentResult): Promise<string> {
+    return result.magnet || '';
+  }
+
+  private parseSizeStr(sizeStr: string): number {
+    if (!sizeStr || typeof sizeStr !== 'string') return 0;
+    const match = sizeStr.match(/([\d.]+)\s*(GB|MB|KB|TB)/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] || 0);
+  }
+
+  private formatSize(bytes: number): string {
+    if (typeof bytes !== 'number' || isNaN(bytes) || bytes === 0) {
+      return 'Unknown';
+    }
+    if (bytes < 1024) return (bytes / 1024).toFixed(2) + ' KB';
+    if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(2) + ' KB';
+    if (bytes < 1024 * 1024 * 1024) return (bytes / (1024 * 1024)).toFixed(2) + ' MB';
+    return (bytes / (1024 * 1024 * 1024)).toFixed(2) + ' GB';
+  }
+}
+
+export default new YtsScraper();

package/src/types.d.ts

@@ -0,0 +1,86 @@
+declare module 'cli-progress' {
+  interface ProgressBarOptions {
+    format?: string;
+    barCompleteChar?: string;
+    barIncompleteChar?: string;
+    hideCursor?: boolean;
+    fps?: number;
+    etaAsynchronous?: boolean;
+    etaBuffer?: number;
+    stream?: any;
+    terminateOnComplete?: boolean;
+  }
+
+  interface ProgressBar {
+    start(total: number, startValue: number, payload?: any): void;
+    update(current: number, payload?: any): void;
+    stop(): void;
+    increment(delta?: number): void;
+  }
+
+  function create(options?: ProgressBarOptions, preset?: any): ProgressBar;
+
+  export = { create };
+}
+
+declare module 'webtorrent' {
+  interface TorrentOptions {
+    path?: string;
+    auto?: boolean;
+    maxWebConns?: number;
+  }
+
+  interface Torrent {
+    ready: boolean;
+    length: number;
+    downloaded: number;
+    name: string;
+    files: any[];
+    on(event: 'ready' | 'download' | 'done' | 'error', callback: (...args: any[]) => void): void;
+  }
+
+  interface Client {
+    add(torrentId: string | Buffer, opts?: TorrentOptions): Torrent;
+    destroy(callback?: () => void): void;
+  }
+
+  function (): Client;
+
+  export = WebTorrent;
+}
+
+declare module 'ora' {
+  interface Ora {
+    start(text?: string): Ora;
+    stop(): Ora;
+    succeed(text?: string): Ora;
+    fail(text?: string): Ora;
+    warn(text?: string): Ora;
+    info(text?: string): Ora;
+    text: string;
+  }
+
+  interface OraOptions {
+    text?: string;
+    color?: string;
+  }
+
+  function ora(options?: OraOptions): Ora;
+
+  export = ora;
+}
+
+declare module 'chalk' {
+  const chalk: {
+    red: (s: string) => string;
+    green: (s: string) => string;
+    blue: (s: string) => string;
+    yellow: (s: string) => string;
+    cyan: (s: string) => string;
+    white: (s: string) => string;
+    gray: (s: string) => string;
+    bold: (s: string) => string;
+  };
+
+  export = chalk;
+}

package/src/types.ts

@@ -0,0 +1,65 @@
+export interface TorrentResult {
+  num: number;
+  name: string;
+  size: string;
+  sizeBytes: number;
+  seeds: number;
+  peers: number;
+  source: string;
+  url: string;
+  magnet?: string;
+  hash?: string;
+  category?: string;
+  date?: string;
+}
+
+export interface SourceConfig {
+  enabled: boolean;
+  name: string;
+  baseUrl: string;
+  searchUrl: string;
+  categories: string[];
+  searchParam: string;
+  hasMagnet: boolean;
+}
+
+export interface SourcesJSON {
+  updateUrl: string;
+  version: string;
+  sources: Record<string, SourceConfig>;
+}
+
+export interface FilterConfig {
+  category: string;
+  minSeeds: number;
+  minSize: string;
+  maxSize: string;
+  sortBy: 'seeds' | 'size' | 'date';
+  order: 'asc' | 'desc';
+  limit: number;
+}
+
+export interface SearchOptions {
+  query: string;
+  category?: string;
+  minSeeds?: number;
+  minSize?: string;
+  maxSize?: string;
+  sortBy?: 'seeds' | 'size' | 'date';
+  order?: 'asc' | 'desc';
+  limit?: number;
+  sources?: string[];
+}
+
+export interface DownloadOptions {
+  torrentUrl?: string;
+  magnet?: string;
+  savePath?: string;
+}
+
+export interface SourceScraper {
+  name: string;
+  search(query: string, category?: string): Promise<TorrentResult[]>;
+  getTorrentUrl(result: TorrentResult): Promise<string>;
+  getMagnet(result: TorrentResult): Promise<string>;
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "noImplicitAny": false
+  },
+  "include": ["src/**/*", "bin/**/*"],
+  "exclude": ["node_modules", "dist"]
+}