tor-dl 1.0.1 → 1.0.3

package/src/cli/parser.ts

@@ -3,6 +3,15 @@ import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
 import { FilterConfig, SearchOptions } from '../types';
 
+function getVersion(): string {
+  try {
+    const pkg = JSON.parse(readFileSync(join(__dirname, '../../package.json'), 'utf-8'));
+    return pkg.version || '1.0.0';
+  } catch {
+    return '1.0.0';
+  }
+}
+
 export function loadFilters(): FilterConfig {
   const filtersPath = join(process.cwd(), 'filters.json');
   if (existsSync(filtersPath)) {
@@ -24,13 +33,8 @@ export function createParser(): Command {
   
   program
     .name('tor-dl')
-    .description('CLI torrent search and download tool')
-    .version('1.0.0')
-    .hook('preAction', (thisCommand) => {
-      if (thisCommand.name() === 'update') {
-        return;
-      }
-    });
+    .description('CLI torrent search tool - search, open in browser, copy magnet links')
+    .version(getVersion(), '-v, --version');
 
   program
     .command('search <query>')
@@ -62,30 +66,19 @@ export function createParser(): Command {
       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();
-    });
+  const openCmd = program.command('open <number>', { hidden: true });
+  openCmd.description('Open .torrent in browser or copy magnet to clipboard');
+  openCmd.action(async (number: string) => {
+    const { openInBrowser } = await import('../commands/download');
+    await openInBrowser(parseInt(number));
+  });
 
-  program
-    .argument('<number>', 'Torrent number to download')
-    .action(async (number: string) => {
-      const { downloadCommand } = await import('../commands/download');
-      await downloadCommand(parseInt(number));
-    });
+  const oCmd = program.command('o <number>');
+  oCmd.description('Open .torrent in browser or copy magnet to clipboard');
+  oCmd.action(async (number: string) => {
+    const { openInBrowser } = await import('../commands/download');
+    await openInBrowser(parseInt(number));
+  });
 
   program.on('command:*', () => {
     console.error('Invalid command: %s\nSee --help for a list of available commands.', program.args[0]);

package/src/commands/download.ts

@@ -1,8 +1,9 @@
 import { displayError, displaySuccess, displayInfo } from '../cli/display';
 import { getCachedResults } from '../download/engine';
-import ora from 'ora';
+import { exec, execSync } from 'child_process';
+import chalk from 'chalk';
 
-export async function downloadCommand(number: number, savePath?: string): Promise<void> {
+export async function openInBrowser(number: number): Promise<void> {
   const results = getCachedResults();
   
   if (results.length === 0) {
@@ -17,20 +18,52 @@ export async function downloadCommand(number: number, savePath?: string): Promis
   
   const result = results[number - 1];
   
-  displayInfo(`Downloading: ${result.name}`);
-  displayInfo(`Source: ${result.source}`);
-  displayInfo(`Size: ${result.size}`);
-  displayInfo(`Seeds: ${result.seeds}\n`);
+  if (!result.torrentUrl && !result.magnet) {
+    displayError('No .torrent URL or magnet available for this result.');
+    process.exit(1);
+  }
   
-  const spinner = ora('Starting download...').start();
+  const url = result.torrentUrl || result.magnet || '';
   
-  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);
+  if (url.startsWith('magnet:')) {
+    try {
+      if (process.platform === 'win32') {
+        execSync(`echo ${url} | clip`, { stdio: 'ignore' });
+      } else if (process.platform === 'darwin') {
+        execSync(`echo "${url}" | pbcopy`, { stdio: 'ignore' });
+      } else {
+        execSync(`echo "${url}" | xclip -selection clipboard`, { stdio: 'ignore' });
+      }
+      displaySuccess('Magnet link copied to clipboard!');
+      console.log(chalk.gray(url));
+    } catch {
+      displayInfo('Magnet link:');
+      console.log(chalk.cyan(url));
+    }
+  } else {
+    displayInfo('Opening: ' + url);
+    const cmd = process.platform === 'win32' ? `start "" "${url}"` : 
+                process.platform === 'darwin' ? `open "${url}"` : 
+                `xdg-open "${url}"`;
+    
+    exec(cmd, (err) => {
+      if (err) {
+        try {
+          if (process.platform === 'win32') {
+            execSync(`echo ${url} | clip`, { stdio: 'ignore' });
+          } else if (process.platform === 'darwin') {
+            execSync(`echo "${url}" | pbcopy`, { stdio: 'ignore' });
+          } else {
+            execSync(`echo "${url}" | xclip -selection clipboard`, { stdio: 'ignore' });
+          }
+          displaySuccess('URL copied to clipboard!');
+        } catch {
+          displayError('Failed to open. Copy this URL manually:');
+          console.log(chalk.cyan(url));
+        }
+      } else {
+        displaySuccess('Opened in browser');
+      }
+    });
   }
 }

package/src/commands/search.ts

@@ -1,53 +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);
+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/download/engine.ts

@@ -1,7 +1,4 @@
-import WebTorrent from 'webtorrent';
-import { DownloadProgress } from '../cli/progress';
-import { TorrentResult, DownloadOptions } from '../types';
-import axios from 'axios';
+import { TorrentResult } from '../types';
 import { writeFileSync, readFileSync, existsSync } from 'fs';
 import { join } from 'path';
 
@@ -34,144 +31,4 @@ export function getCachedResults(): TorrentResult[] {
     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 "tor-dl 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/index.ts

@@ -1,7 +1,6 @@
 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';

package/src/sources/nyaa.ts

@@ -36,6 +36,8 @@ export class NyaaScraper implements SourceScraper {
         const peers = parseInt($(el).find('td:nth-child(7)').text().trim()) || 0;
         
         if (title && title.length > 3) {
+          const idMatch = link.match(/\/view\/(\d+)/);
+          const torrentUrl = idMatch ? `https://nyaa.si/download/${idMatch[1]}.torrent` : '';
           results.push({
             num: results.length + 1,
             name: title,
@@ -45,6 +47,7 @@ export class NyaaScraper implements SourceScraper {
             peers,
             source: 'Nyaa',
             url: link,
+            torrentUrl,
             magnet: ''
           });
         }

package/src/sources/thepiratebay.ts

@@ -30,6 +30,7 @@ export class ThePirateBayScraper implements SourceScraper {
         peers: parseInt(item.leechers) || 0,
         source: 'ThePirateBay',
         url: `https://thepiratebay.org/torrent/${item.id}`,
+        torrentUrl: `magnet:?xt=urn:btih:${item.info_hash}`,
         magnet: `magnet:?xt=urn:btih:${item.info_hash}`,
         hash: item.info_hash
       }));

package/src/sources/yts.ts

@@ -34,6 +34,7 @@ export class YtsScraper implements SourceScraper {
             peers: movie.torrents?.[0]?.peers || 0,
             source: 'YTS',
             url: movie.torrents?.[0]?.url || '',
+            torrentUrl: movie.torrents?.[0]?.url || '',
             magnet: movie.torrents?.[0]?.hash ? `magnet:?xt=urn:btih:${movie.torrents[0].hash}` : '',
             hash: movie.torrents?.[0]?.hash
           });

package/src/types.ts

@@ -11,6 +11,7 @@ export interface TorrentResult {
   hash?: string;
   category?: string;
   date?: string;
+  torrentUrl?: string;
 }
 
 export interface SourceConfig {

package/bin/tordl.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-const { createParser } = require('../dist/cli/parser');
-
-const program = createParser();
-program.parse(process.argv);

package/dist/bin/torrent-cli.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-const { createParser } = require('../cli/parser');
-
-const program = createParser();
-program.parse(process.argv);

package/src/cli/progress.ts

@@ -1,78 +0,0 @@
-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;
-  }
-}