tor-dl 1.0.0

package/src/cli/parser.ts

@@ -0,0 +1,96 @@
+import { Command } from 'commander';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { FilterConfig, SearchOptions } from '../types';
+
+export function loadFilters(): FilterConfig {
+  const filtersPath = join(process.cwd(), 'filters.json');
+  if (existsSync(filtersPath)) {
+    return JSON.parse(readFileSync(filtersPath, 'utf-8'));
+  }
+  return {
+    category: 'all',
+    minSeeds: 0,
+    minSize: '0',
+    maxSize: '50GB',
+    sortBy: 'seeds',
+    order: 'desc',
+    limit: 50
+  };
+}
+
+export function createParser(): Command {
+  const program = new Command();
+  
+  program
+    .name('tordl')
+    .description('CLI torrent search and download tool')
+    .version('1.0.0')
+    .hook('preAction', (thisCommand) => {
+      if (thisCommand.name() === 'update') {
+        return;
+      }
+    });
+
+  program
+    .command('search <query>')
+    .description('Search for torrents')
+    .option('-c, --cat <category>', 'Category: all, movie, tv')
+    .option('-s, --min-seeds <number>', 'Minimum seeds', parseInt)
+    .option('--min-size <size>', 'Minimum size (e.g., 500MB, 1GB)')
+    .option('--max-size <size>', 'Maximum size (e.g., 5GB)')
+    .option('-o, --sort <sortBy>', 'Sort by: seeds, size, date')
+    .option('--order <order>', 'Order: asc, desc')
+    .option('-l, --limit <limit>', 'Result limit', parseInt)
+    .option('--sources <sources>', 'Comma-separated source names')
+    .action(async (query: string, options) => {
+      const filters = loadFilters();
+      
+      const searchOptions: SearchOptions = {
+        query,
+        category: options.cat || filters.category,
+        minSeeds: options.minSeeds ?? filters.minSeeds,
+        minSize: options.minSize || filters.minSize,
+        maxSize: options.maxSize || filters.maxSize,
+        sortBy: (options.sort as 'seeds' | 'size' | 'date') || filters.sortBy,
+        order: (options.order as 'asc' | 'desc') || filters.order,
+        limit: options.limit || filters.limit,
+        sources: options.sources ? options.sources.split(',') : undefined
+      };
+
+      const { searchCommand } = await import('../commands/search');
+      await searchCommand(searchOptions);
+    });
+
+  program
+    .command('download <number>')
+    .description('Download a torrent by number from previous search')
+    .option('-p, --path <path>', 'Download path')
+    .action(async (number: string, options) => {
+      const { downloadCommand } = await import('../commands/download');
+      await downloadCommand(parseInt(number), options.path);
+    });
+
+  program
+    .command('update')
+    .description('Update sources from remote config')
+    .alias('u')
+    .action(async () => {
+      const { updateCommand } = await import('../commands/update');
+      await updateCommand();
+    });
+
+  program
+    .argument('<number>', 'Torrent number to download')
+    .action(async (number: string) => {
+      const { downloadCommand } = await import('../commands/download');
+      await downloadCommand(parseInt(number));
+    });
+
+  program.on('command:*', () => {
+    console.error('Invalid command: %s\nSee --help for a list of available commands.', program.args[0]);
+    process.exit(1);
+  });
+
+  return program;
+}

package/src/cli/progress.ts

@@ -0,0 +1,78 @@
+import cliProgress from 'cli-progress';
+import chalk from 'chalk';
+
+export class DownloadProgress {
+  private bar: cliProgress.SingleBar;
+  private startTime: number;
+  private totalBytes: number = 0;
+  private downloadedBytes: number = 0;
+
+  constructor() {
+    this.startTime = Date.now();
+    this.bar = new cliProgress.SingleBar({
+      format: '[{bar}] {percentage}% | {speed} | ETA: {eta} | {downloaded}',
+      barCompleteChar: '\u2588',
+      barIncompleteChar: '\u2591',
+      hideCursor: true,
+      fps: 10,
+      etaAsynchronous: true
+    });
+  }
+
+  start(total: number): void {
+    this.totalBytes = total;
+    this.bar.start(total, 0, {
+      speed: '0 B/s',
+      downloaded: '0 MB'
+    });
+  }
+
+  update(downloaded: number, total: number): void {
+    this.downloadedBytes = downloaded;
+    this.totalBytes = total || this.totalBytes;
+    
+    const speed = this.calculateSpeed();
+    const eta = this.calculateETA();
+    const downloadedMB = (this.downloadedBytes / (1024 * 1024)).toFixed(2);
+    
+    this.bar.update(this.downloadedBytes, {
+      speed,
+      downloaded: `${downloadedMB} MB`,
+      eta
+    });
+  }
+
+  private calculateSpeed(): string {
+    const elapsed = (Date.now() - this.startTime) / 1000;
+    const bytesPerSecond = elapsed > 0 ? this.downloadedBytes / elapsed : 0;
+    return this.formatBytes(bytesPerSecond) + '/s';
+  }
+
+  private calculateETA(): string {
+    const elapsed = (Date.now() - this.startTime) / 1000;
+    if (this.downloadedBytes === 0 || this.totalBytes === 0) return 'N/A';
+    
+    const speed = this.downloadedBytes / elapsed;
+    const remaining = this.totalBytes - this.downloadedBytes;
+    const seconds = remaining / speed;
+    
+    if (seconds < 60) return `${Math.round(seconds)}s`;
+    if (seconds < 3600) return `${Math.floor(seconds / 60)}m ${Math.round(seconds % 60)}s`;
+    return `${Math.floor(seconds / 3600)}h ${Math.floor((seconds % 3600) / 60)}m`;
+  }
+
+  private formatBytes(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';
+  }
+
+  stop(): void {
+    this.bar.stop();
+  }
+
+  getTotalDownloaded(): number {
+    return this.downloadedBytes;
+  }
+}

package/src/commands/download.ts

@@ -0,0 +1,36 @@
+import { displayError, displaySuccess, displayInfo } from '../cli/display';
+import { getCachedResults } from '../download/engine';
+import ora from 'ora';
+
+export async function downloadCommand(number: number, savePath?: string): Promise<void> {
+  const results = getCachedResults();
+  
+  if (results.length === 0) {
+    displayError('No search results found. Run "tordl search <query>" first.');
+    process.exit(1);
+  }
+  
+  if (number < 1 || number > results.length) {
+    displayError(`Invalid selection. Choose a number between 1 and ${results.length}.`);
+    process.exit(1);
+  }
+  
+  const result = results[number - 1];
+  
+  displayInfo(`Downloading: ${result.name}`);
+  displayInfo(`Source: ${result.source}`);
+  displayInfo(`Size: ${result.size}`);
+  displayInfo(`Seeds: ${result.seeds}\n`);
+  
+  const spinner = ora('Starting download...').start();
+  
+  try {
+    const { downloadTorrent } = await import('../download/engine');
+    await downloadTorrent(result, { savePath });
+    spinner.succeed('Download complete!');
+  } catch (error: any) {
+    spinner.fail(`Download failed: ${error.message}`);
+    displayError('Make sure you have a stable internet connection and sufficient disk space.');
+    process.exit(1);
+  }
+}

package/src/commands/search.ts

@@ -0,0 +1,53 @@
+import ora from 'ora';
+import { SearchOptions, TorrentResult } from '../types';
+import { getEnabledSources } from '../sources/registry';
+import { filterByCategory, filterBySize, filterBySeeds, sortResults } from '../filters';
+import { displayResults, displayError } from '../cli/display';
+import { cacheResults } from '../download/engine';
+
+export async function searchCommand(options: SearchOptions): Promise<void> {
+  const spinner = ora('Searching torrent sources...').start();
+  
+  let sources = getEnabledSources();
+  
+  if (options.sources && options.sources.length > 0) {
+    const requested = options.sources.map(s => s.toLowerCase());
+    sources = sources.filter(s => requested.includes(s.name.toLowerCase()));
+  }
+  
+  const allResults: TorrentResult[] = [];
+  
+  for (const source of sources) {
+    try {
+      spinner.text = `Searching ${source.name}...`;
+      const results = await source.search(options.query, options.category);
+      allResults.push(...results);
+    } catch (error) {
+      spinner.warn(`Failed to search ${source.name}`);
+    }
+  }
+  
+  spinner.succeed(`Search complete. Found ${allResults.length} results.`);
+  
+  let filtered = filterByCategory(allResults, options.category || 'all');
+  
+  if (options.minSeeds && options.minSeeds > 0) {
+    filtered = filterBySeeds(filtered, options.minSeeds);
+  }
+  
+  if (options.minSize || options.maxSize) {
+    filtered = filterBySize(filtered, options.minSize, options.maxSize);
+  }
+  
+  filtered = sortResults(filtered, options.sortBy || 'seeds', options.order || 'desc');
+  
+  if (options.limit && options.limit > 0) {
+    filtered = filtered.slice(0, options.limit);
+  }
+  
+  filtered = filtered.map((r, i) => ({ ...r, num: i + 1 }));
+  
+  cacheResults(filtered);
+  
+  displayResults(filtered);
+}

package/src/commands/update.ts

@@ -0,0 +1,30 @@
+import axios from 'axios';
+import { writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { displaySuccess, displayError, displayInfo } from '../cli/display';
+import { getUpdateUrl } from '../sources/registry';
+
+export async function updateCommand(): Promise<void> {
+  const updateUrl = getUpdateUrl();
+  
+  if (!updateUrl) {
+    displayError('No update URL configured. Update sources.json with an updateUrl first.');
+    return;
+  }
+  
+  displayInfo(`Fetching latest sources from: ${updateUrl}`);
+  
+  try {
+    const { data } = await axios.get(updateUrl, { timeout: 15000 });
+    
+    const localPath = join(process.cwd(), 'sources.json');
+    writeFileSync(localPath, JSON.stringify(data, null, 2));
+    
+    displaySuccess('Sources updated successfully!');
+    displayInfo(`Updated to version: ${data.version || 'unknown'}`);
+    displayInfo(`Sources: ${Object.keys(data.sources || {}).join(', ')}`);
+  } catch (error: any) {
+    displayError(`Failed to update sources: ${error.message}`);
+    displayInfo('Check your internet connection and the update URL.');
+  }
+}

package/src/download/engine.ts

@@ -0,0 +1,177 @@
+import WebTorrent from 'webtorrent';
+import { DownloadProgress } from '../cli/progress';
+import { TorrentResult, DownloadOptions } from '../types';
+import axios from 'axios';
+import { writeFileSync, readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+const CACHE_FILE = join(process.cwd(), '.torrent-cache.json');
+
+function saveCache(results: TorrentResult[]): void {
+  try {
+    writeFileSync(CACHE_FILE, JSON.stringify(results, null, 2));
+  } catch (e) { /* ignore */ }
+}
+
+function loadCache(): TorrentResult[] {
+  try {
+    if (existsSync(CACHE_FILE)) {
+      return JSON.parse(readFileSync(CACHE_FILE, 'utf-8'));
+    }
+  } catch (e) { /* ignore */ }
+  return [];
+}
+
+let cachedResults: TorrentResult[] = [];
+
+export function cacheResults(results: TorrentResult[]): void {
+  cachedResults = results;
+  saveCache(results);
+}
+
+export function getCachedResults(): TorrentResult[] {
+  if (cachedResults.length === 0) {
+    cachedResults = loadCache();
+  }
+  return cachedResults;
+}
+
+export async function downloadTorrent(
+  result: TorrentResult,
+  options: DownloadOptions = {}
+): Promise<void> {
+  const client = new WebTorrent();
+  const progress = new DownloadProgress();
+  const savePath = options.savePath || process.cwd();
+  
+  let torrentId: string;
+  
+  if (result.magnet && result.magnet.startsWith('magnet:')) {
+    torrentId = result.magnet;
+  } else if (result.url && result.url.includes('magnet:')) {
+    torrentId = result.url;
+  } else if (result.url && result.url.includes('nyaa.si')) {
+    console.log('Fetching magnet link from Nyaa...');
+    const magnet = await getMagnetFromResult(result);
+    if (magnet) {
+      torrentId = magnet;
+    } else {
+      throw new Error('Could not get magnet link from Nyaa page');
+    }
+  } else {
+    console.log('Fetching torrent file...');
+    const torrentUrl = await getTorrentUrl(result);
+    if (torrentUrl) {
+      const response = await axios.get(torrentUrl, { responseType: 'arraybuffer' });
+      const tempFile = join(savePath, 'temp.torrent');
+      writeFileSync(tempFile, response.data);
+      torrentId = tempFile;
+    } else {
+      throw new Error('Could not get torrent URL');
+    }
+  }
+  
+  console.log(`\nDownloading: ${result.name}`);
+  console.log(`Saving to: ${savePath}\n`);
+  
+  return new Promise((resolve, reject) => {
+    console.log('Adding torrent to client...');
+    console.log('Torrent ID:', torrentId.substring(0, 60) + '...');
+    
+    const torrent = client.add(torrentId, {
+      path: savePath
+    });
+    
+    torrent.on('warning', (warn) => {
+      console.log('Torrent warning:', warn.message);
+    });
+    
+    torrent.on('peer', (peer) => {
+      console.log('New peer connected:', peer);
+    });
+    
+    console.log('Torrent added, waiting for ready...');
+    
+    torrent.on('ready', () => {
+      const total = torrent.length;
+      console.log(`✓ Torrent ready! Total size: ${(total / (1024*1024)).toFixed(2)} MB`);
+      console.log(`  Files: ${torrent.files.map(f => f.name).join(', ')}`);
+      console.log(`  Info hash: ${torrent.infoHash}`);
+      progress.start(total);
+      
+      torrent.on('download', (bytes: number) => {
+        const percent = ((torrent.downloaded / total) * 100).toFixed(1);
+        process.stdout.write(`\rDownloading: ${percent}% (${(torrent.downloaded/1024/1024).toFixed(1)} MB / ${(total/1024/1024).toFixed(1)} MB) - ${torrent.peers.length} peers   `);
+        progress.update(torrent.downloaded, total);
+      });
+      
+      torrent.on('done', () => {
+        progress.stop();
+        console.log('\n\n✓ Download complete!');
+        console.log(`Downloaded to: ${savePath}`);
+        client.destroy();
+        resolve();
+      });
+    });
+    
+    torrent.on('error', (err: Error) => {
+      console.error('\nDownload error:', err.message);
+      client.destroy();
+      reject(err);
+    });
+    
+    setTimeout(() => {
+      console.log('\n\nDebug:');
+      console.log('  Downloaded:', torrent.downloaded);
+      console.log('  Length:', torrent.length);
+      console.log('  Peers:', torrent.peers?.length || 0);
+      console.log('  Done:', torrent.done);
+      
+      if (torrent.downloaded > 0) {
+        console.log('\nDownload in progress but taking long...');
+        console.log(`Progress: ${(torrent.downloaded/torrent.length*100).toFixed(1)}%`);
+      } else {
+        console.log('\nNo progress after 60s - may be stuck or no peers');
+      }
+    }, 60000);
+  });
+}
+
+async function getTorrentUrl(result: TorrentResult): Promise<string> {
+  if (result.magnet && result.magnet.startsWith('magnet:')) {
+    return result.magnet;
+  }
+  return result.url;
+}
+
+async function getMagnetFromResult(result: TorrentResult): Promise<string> {
+  if (result.magnet) return result.magnet;
+  if (!result.url) return '';
+  
+  try {
+    const { data } = await axios.get(result.url, { timeout: 15000 });
+    const cheerio = require('cheerio');
+    const $ = cheerio.load(data);
+    return $('a[href^="magnet:"]').attr('href') || '';
+  } catch {
+    return '';
+  }
+}
+
+export async function downloadByNumber(
+  number: number,
+  savePath?: string
+): Promise<void> {
+  const results = getCachedResults();
+  
+  if (results.length === 0) {
+    throw new Error('No search results. Run "tordl search" first.');
+  }
+  
+  if (number < 1 || number > results.length) {
+    throw new Error(`Invalid number. Choose between 1 and ${results.length}`);
+  }
+  
+  const result = results[number - 1];
+  await downloadTorrent(result, { savePath });
+}

package/src/filters/category.ts

@@ -0,0 +1,26 @@
+import { TorrentResult } from '../types';
+
+export function filterByCategory(results: TorrentResult[], category: string): TorrentResult[] {
+  if (!category || category === 'all') {
+    return results;
+  }
+  
+  return results.filter(r => {
+    const name = r.name.toLowerCase();
+    const cat = category.toLowerCase();
+    
+    if (cat === 'movie') {
+      return name.includes('movie') || name.includes('720p') || name.includes('1080p') || 
+             name.includes('2160p') || name.includes('bluray') || name.includes('brrip') ||
+             name.includes('webrip') || name.includes('web-dl') || name.includes('dvdrip');
+    }
+    
+    if (cat === 'tv') {
+      return name.includes('s01') || name.includes('s02') || name.includes('episode') ||
+             name.includes('season') || name.includes('tv') || name.includes('hdtv') ||
+             name.includes('webrip') || name.includes('web-dl');
+    }
+    
+    return true;
+  });
+}

package/src/filters/index.ts

@@ -0,0 +1,4 @@
+export { filterByCategory } from './category';
+export { filterBySize, parseSize } from './size';
+export { filterBySeeds } from './seeds';
+export { sortResults, SortField, SortOrder } from './sort';

package/src/filters/seeds.ts

@@ -0,0 +1,5 @@
+import { TorrentResult } from '../types';
+
+export function filterBySeeds(results: TorrentResult[], minSeeds: number = 0): TorrentResult[] {
+  return results.filter(r => r.seeds >= minSeeds);
+}

package/src/filters/size.ts

@@ -0,0 +1,42 @@
+import { TorrentResult } from '../types';
+
+export function parseSize(size: string): number {
+  if (!size || size === 'Unknown' || size === 'N/A') return 0;
+  
+  const match = size.toString().match(/([\d.]+)\s*(GB|MB|TB|KB|B)/i);
+  if (!match) return 0;
+  
+  const value = parseFloat(match[1]);
+  const unit = match[2].toUpperCase();
+  
+  const multipliers: Record<string, number> = {
+    'B': 1,
+    'KB': 1024,
+    'MB': 1024 ** 2,
+    'GB': 1024 ** 3,
+    'TB': 1024 ** 4
+  };
+  
+  return value * (multipliers[unit] || 1);
+}
+
+export function filterBySize(
+  results: TorrentResult[],
+  minSize?: string,
+  maxSize?: string
+): TorrentResult[] {
+  if (!minSize && !maxSize) {
+    return results;
+  }
+  
+  const minBytes = minSize ? parseSize(minSize) : 0;
+  const maxBytes = maxSize && maxSize !== '0' ? parseSize(maxSize) : Number.MAX_SAFE_INTEGER;
+  
+  return results.filter(r => {
+    const sizeBytes = r.sizeBytes;
+    if (typeof sizeBytes !== 'number' || isNaN(sizeBytes)) {
+      return true;
+    }
+    return sizeBytes >= minBytes && sizeBytes <= maxBytes;
+  });
+}

package/src/filters/sort.ts

@@ -0,0 +1,34 @@
+import { TorrentResult } from '../types';
+
+export type SortField = 'seeds' | 'size' | 'date';
+export type SortOrder = 'asc' | 'desc';
+
+export function sortResults(
+  results: TorrentResult[],
+  sortBy: SortField = 'seeds',
+  order: SortOrder = 'desc'
+): TorrentResult[] {
+  const sorted = [...results];
+  
+  sorted.sort((a, b) => {
+    let comparison = 0;
+    
+    switch (sortBy) {
+      case 'seeds':
+        comparison = a.seeds - b.seeds;
+        break;
+      case 'size':
+        comparison = (a.sizeBytes || 0) - (b.sizeBytes || 0);
+        break;
+      case 'date':
+        comparison = (a.date || '').localeCompare(b.date || '');
+        break;
+      default:
+        comparison = a.seeds - b.seeds;
+    }
+    
+    return order === 'desc' ? -comparison : comparison;
+  });
+  
+  return sorted;
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+export * from './types';
+export { createParser, loadFilters } from './cli/parser';
+export * from './cli/display';
+export * from './cli/progress';
+export * from './sources/registry';
+export * from './filters';
+export * from './download/engine';
+export * from './commands/search';
+export * from './commands/download';
+export * from './commands/update';

package/src/sources/1337x.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 _1337xScraper implements SourceScraper {
+  name = '1337x';
+
+  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] ? `/category-${catMap[category]}` : '';
+      const url = `https://1337x.to${catParam}/search/${encodeURIComponent(query)}/1/`;
+      
+      const { data } = await axios.get(url, {
+        headers: DEFAULT_HEADERS,
+        timeout: TIMEOUT
+      });
+      
+      const $ = cheerio.load(data);
+      const results: TorrentResult[] = [];
+      
+      $('table.table-list tbody tr').each((i, el) => {
+        const title = $(el).find('td.coll-1 a').last().text().trim() || $(el).find('td.coll-1').text().trim();
+        const size = $(el).find('td.coll-4').text().trim();
+        const seeds = parseInt($(el).find('td.coll-2').text().trim()) || 0;
+        const peers = parseInt($(el).find('td.coll-3').text().trim()) || 0;
+        const link = 'https://1337x.to' + ($(el).find('td.coll-1 a').last().attr('href') || '');
+        
+        if (title) {
+          results.push({
+            num: results.length + 1,
+            name: title,
+            size: size || 'Unknown',
+            sizeBytes: this.parseSize(size),
+            seeds,
+            peers,
+            source: '1337x',
+            url: link,
+            magnet: ''
+          });
+        }
+      });
+      
+      return results;
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      console.error(`1337x 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 || result.url;
+    } catch {
+      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 _1337xScraper();