termsearch 0.3.14 → 0.3.15

package/README.md

@@ -27,7 +27,7 @@ Opens `http://localhost:3000`. That's it.
 
 **Social Profiler** — Paste a GitHub/Bluesky/Reddit/Twitter URL or @handle, get a profile card with stats, top repos, similar accounts.
 
-**Torrent Search** — The Pirate Bay + 1337x with magnet links, seeders, file sizes.
+**Torrent Search** — The Pirate Bay, 1337x, YTS, Nyaa, EZTV, and Torrent Galaxy with magnet links, seeders, file sizes.
 
 **Social & News** — Bluesky posts + GDELT articles inline.
 
@@ -84,7 +84,7 @@ Load Models button auto-discovers available models from the endpoint.
 
 **Self-hosted**: SearXNG (proxy to 40+ engines)
 
-**Selectable per-search**: Engine picker icon in the header lets you toggle individual engines, use presets (All / Balanced / GitHub Focus), or pick from groups (Web Core, Uncensored, Code & Dev, Media, Research, Federated, Torrent).
+**Selectable per-search**: Engine picker icon in the header lets you toggle individual engines, use presets (All / Web / Uncensored / GitHub / Torrent / Social / Research), or pick from groups (Web Core, Uncensored, Code & Dev, Media, Research, Federated, Torrent).
 
 ## Frontend
 
@@ -121,7 +121,7 @@ src/
   fetch/               document fetcher + SSRF guard
   profiler/            social profile scanner (10 platforms)
   social/              Bluesky + GDELT + scrapers
-  torrent/             TPB + 1337x + magnet extraction
+  torrent/             TPB + 1337x + YTS + Nyaa + EZTV + TGx + magnet extraction
   autostart/           Termux:Boot / systemd / launchd
   api/                 routes + middleware
 

package/frontend/dist/app.js

@@ -102,7 +102,7 @@ function route() {
   const params = new URLSearchParams(queryIdx >= 0 ? hash.slice(queryIdx + 1) : '');
   const q = params.get('q') || '';
   const cat = (params.get('cat') || 'web').toLowerCase();
-  state.category = ['web', 'images', 'news'].includes(cat) ? cat : 'web';
+  state.category = ['web', 'images', 'news', 'torrent'].includes(cat) ? cat : 'web';
   if (q && (q !== state.query || state.results.length === 0)) {
     state.query = q;
     doSearch(q);
@@ -278,13 +278,17 @@ const ENGINE_GROUPS = [
   { label: 'Media', items: ['youtube', 'sepiasearch'] },
   { label: 'Research', items: ['wikidata', 'crossref', 'openalex', 'openlibrary'] },
   { label: 'Federated', items: ['mastodon users', 'mastodon hashtags', 'tootfinder', 'lemmy communities', 'lemmy posts'] },
-  { label: 'Torrent', items: ['piratebay', '1337x', 'nyaa'] },
+  { label: 'Torrent', items: ['piratebay', '1337x', 'yts', 'nyaa', 'eztv', 'tgx'] },
 ];
 
 const ENGINE_PRESETS = [
-  { id: 'all', label: 'All', engines: [] },
-  { id: 'balanced', label: 'Balanced', engines: ['duckduckgo', 'wikipedia', 'bing', 'brave', 'github', 'reddit', 'youtube'] },
-  { id: 'github', label: 'GitHub Focus', engines: ['github-api', 'github', 'duckduckgo', 'wikipedia'] },
+  { id: 'all',        label: 'All',        engines: [] },
+  { id: 'web',        label: 'Web',        engines: ['duckduckgo', 'startpage', 'qwant', 'ecosia', 'wikipedia'] },
+  { id: 'uncensored', label: 'Uncensored', engines: ['yandex', 'marginalia', 'ahmia', 'duckduckgo'] },
+  { id: 'github',     label: 'GitHub',     engines: ['github-api', 'github', 'duckduckgo', 'wikipedia'] },
+  { id: 'torrent',    label: 'Torrent',    engines: ['piratebay', '1337x', 'yts', 'nyaa', 'eztv', 'tgx'] },
+  { id: 'social',     label: 'Social',     engines: ['reddit', 'hackernews', 'youtube', 'mastodon users', 'lemmy posts'] },
+  { id: 'research',   label: 'Research',   engines: ['wikipedia', 'wikidata', 'crossref', 'openalex', 'openlibrary'] },
 ];
 
 // ─── Engine availability (requires config) ────────────────────────────────
@@ -294,7 +298,7 @@ const SEARXNG_ROUTED = new Set([
   'wikidata', 'crossref', 'openalex', 'openlibrary',
   'mastodon users', 'mastodon hashtags', 'tootfinder',
   'lemmy communities', 'lemmy posts',
-  'piratebay', '1337x', 'nyaa',
+  // piratebay, 1337x, nyaa, yts, eztv, tgx — native scrapers, always available
 ]);
 
 function isEngineAvailable(engine) {
@@ -304,6 +308,7 @@ function isEngineAvailable(engine) {
   if (engine === 'yandex')     return cfg.yandex?.enabled !== false;
   if (engine === 'ahmia')      return cfg.ahmia?.enabled !== false;
   if (engine === 'marginalia') return cfg.marginalia?.enabled !== false;
+  if (['piratebay', '1337x', 'yts', 'nyaa', 'eztv', 'tgx'].includes(engine)) return true;
   if (engine === 'startpage') return (state.config?.startpage?.enabled) !== false;
   if (engine === 'qwant')     return (state.config?.qwant?.enabled)     !== false;
   if (engine === 'ecosia')    return (state.config?.ecosia?.enabled)     !== false;
@@ -362,16 +367,19 @@ function EnginePicker(opts = {}) {
   const presetRow = el('div', { className: 'engine-preset-row' });
   ENGINE_PRESETS.forEach((preset) => {
     const isActive = preset.id === 'all' ? isAll
-      : preset.engines.length > 0 && preset.engines.every(e => state.selectedEngines.includes(e)) && state.selectedEngines.length === preset.engines.length;
+      : preset.engines.length > 0
+        && preset.engines.every(e => state.selectedEngines.includes(e))
+        && state.selectedEngines.length === preset.engines.length;
     presetRow.append(el('button', {
-      className: `btn ${isActive || preset.id === 'balanced' ? 'btn-primary' : ''}`,
+      className: `btn ${isActive ? 'btn-primary' : ''}`,
       type: 'button',
       onClick: () => {
-        // 'all' preset → clear filter (backend uses all configured providers)
         setSelectedEngines(preset.id === 'all' ? [] : preset.engines);
-        // visually check/uncheck all available chips
-        [...details.querySelectorAll('.engine-chip input:not(:disabled)')].forEach((input) => {
-          input.checked = preset.id === 'all' || preset.engines.includes(input.closest('.engine-chip')?.querySelector('span')?.textContent?.trim().toLowerCase() || '');
+        // update chip checkboxes via data-engine attribute
+        [...details.querySelectorAll('.engine-chip input')].forEach((input) => {
+          const engine = input.closest('.engine-chip')?.dataset?.engine || '';
+          if (input.disabled) return;
+          input.checked = preset.id === 'all' || preset.engines.includes(engine);
         });
       },
     }, preset.label));
@@ -392,7 +400,7 @@ function EnginePicker(opts = {}) {
       const input = el('input', inputAttrs);
       const chipClass = `engine-chip${available ? '' : ' engine-chip-unavailable'}`;
       const title = available ? engine : `${engine} — not configured (Settings)`;
-      const label = el('label', { className: chipClass, for: id, title },
+      const label = el('label', { className: chipClass, for: id, title, 'data-engine': engine },
         input,
         el('span', {}, engine),
       );
@@ -409,7 +417,7 @@ function EnginePicker(opts = {}) {
       type: 'button',
       onClick: () => {
         const checked = [...details.querySelectorAll('.engine-chip input:not(:disabled):checked')]
-          .map((node) => node.closest('.engine-chip')?.querySelector('span')?.textContent?.trim().toLowerCase())
+          .map((node) => node.closest('.engine-chip')?.dataset?.engine || '')
           .filter(Boolean);
         const availableAll = ENGINE_GROUPS.flatMap(g => g.items).filter(isEngineAvailable);
         // If all available engines are checked, send [] (no filter)
@@ -851,6 +859,8 @@ function SocialPanel(results) {
 }
 
 // ─── Search logic ─────────────────────────────────────────────────────────
+const TORRENT_QUERY_RE = /\b(torrent|magnet|\.iso|\.mkv|\.avi|\.mp4|720p|1080p|2160p|4k|uhd|season|s\d{1,2}e\d{1,2}|xvid|x264|x265|hevc|blu.?ray|webrip|dvdrip|bdrip|hdtv|yify|yts|piratebay|1337x|nyaa|eztv|tgx|download\s+film|download\s+serie|scarica\s+film)\b/i;
+
 function isProfileQuery(q) {
   return /^https?:\/\/(github|twitter|x|instagram|bluesky|reddit|linkedin|youtube|tiktok|telegram|facebook)/.test(q)
     || /^@[a-zA-Z0-9_\.]{2,}$/.test(q)
@@ -947,7 +957,10 @@ async function runSearchProgressive(q, lang, category, engines = []) {
 async function doSearch(q, category = state.category) {
   if (!q.trim()) return;
   addSearchToHistory(q);
-  state.category = ['web', 'images', 'news'].includes(category) ? category : 'web';
+  const VALID_CATS = ['web', 'images', 'news', 'torrent'];
+  // Fast torrent intent detection — only auto-switch if user is on the default web tab
+  if (TORRENT_QUERY_RE.test(q) && category === 'web') category = 'torrent';
+  state.category = VALID_CATS.includes(category) ? category : 'web';
   state.loading = true;
   state.results = [];
   state.aiSummary = '';
@@ -955,7 +968,7 @@ async function doSearch(q, category = state.category) {
   state.aiError = null;
   state.aiMeta = null;
   state.profilerData = null;
-  state.profilerLoading = isProfileQuery(q);
+  state.profilerLoading = false;
   state.torrentData = [];
   state.socialData = [];
   renderApp();
@@ -963,7 +976,33 @@ async function doSearch(q, category = state.category) {
   const lang = getResolvedLang();
   const engines = state.selectedEngines.slice();
 
+  // ── Torrent category: direct scraper, no stream ──────────────────────────
+  if (state.category === 'torrent') {
+    try {
+      const res = await api('/api/torrent-search', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ q }),
+      });
+      state.loading = false;
+      state.torrentData = res?.results || [];
+      state.providers = res?.source ? [res.source] : [];
+    } catch {
+      state.loading = false;
+      state.torrentData = [];
+    }
+    renderApp();
+    return;
+  }
+
   try {
+    // AI query intent — runs in parallel with search, uses result to extend engines
+    const aiQueryPromise = api('/api/ai-query', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ query: q, lang }),
+    }).catch(() => null);
+
     const searchPromise = runSearchProgressive(q, lang, state.category, engines).catch(async () => {
       const p = new URLSearchParams({ q, lang, cat: state.category });
       if (engines.length > 0) p.set('engines', engines.join(','));
@@ -974,16 +1013,46 @@ async function doSearch(q, category = state.category) {
       api(`/api/social-search?q=${encodeURIComponent(q)}`).catch(() => null),
     ];
 
-    if (state.profilerLoading) {
-      promises.push(
-        api(`/api/profiler?q=${encodeURIComponent(q)}`).catch(() => null)
-      );
+    if (isProfileQuery(q)) {
+      state.profilerLoading = true;
+      promises.push(api(`/api/profiler?q=${encodeURIComponent(q)}`).catch(() => null));
     } else {
       promises.push(Promise.resolve(null));
     }
 
     const [searchRes, socialRes, profilerRes] = await Promise.all(promises);
 
+    // Use AI intent routing: if also_search_on has engines the user didn't select, run a second pass
+    const aiQuery = await aiQueryPromise;
+    if (aiQuery?.also_search_on?.length && state.category === 'web' && !engines.length) {
+      // AI suggested category switch (e.g. torrent) — honour it if user didn't pick manually
+      if (aiQuery.category === 'torrent' && state.category !== 'torrent') {
+        state.category = 'torrent';
+        navigate(buildSearchHash(q, 'torrent'));
+        const torRes = await api('/api/torrent-search', {
+          method: 'POST', headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ q }),
+        }).catch(() => null);
+        state.loading = false;
+        state.torrentData = torRes?.results || [];
+        state.providers = torRes?.source ? [torRes.source] : [];
+        renderApp();
+        return;
+      }
+      // Otherwise run a second search with the AI-suggested engines (non-blocking supplement)
+      const p2 = new URLSearchParams({ q, lang, cat: 'web', engines: aiQuery.also_search_on.join(',') });
+      api(`/api/search?${p2}`).then((extra) => {
+        if (!extra?.results?.length) return;
+        const existing = new Set(state.results.map(r => r.url));
+        const fresh = extra.results.filter(r => !existing.has(r.url));
+        if (fresh.length) {
+          state.results = [...state.results, ...fresh];
+          state.providers = [...new Set([...state.providers, ...(extra.providers || [])])];
+          renderApp();
+        }
+      }).catch(() => null);
+    }
+
     state.loading = false;
     state.results = searchRes?.results || state.results || [];
     state.providers = searchRes?.providers || state.providers || [];
@@ -995,7 +1064,7 @@ async function doSearch(q, category = state.category) {
     state.profilerData = profilerRes;
     state.profilerLoading = false;
 
-    // Torrent results (from main search or extracted by engine)
+    // Torrent results extracted from web search
     state.torrentData = state.results.filter(r => r.magnetLink || r.engine?.includes('torrent') || r.engine?.includes('piratebay') || r.engine?.includes('1337x'));
 
     renderApp();
@@ -1107,9 +1176,10 @@ function renderApp() {
 
   const categoryBar = el('div', { className: 'category-tabs hide-mobile' });
   const categories = [
-    { id: 'web', label: 'Web' },
-    { id: 'images', label: 'Images' },
-    { id: 'news', label: 'News' },
+    { id: 'web',     label: 'Web' },
+    { id: 'images',  label: 'Images' },
+    { id: 'news',    label: 'News' },
+    { id: 'torrent', label: 'Torrent' },
   ];
   const buildCatTabs = (container) => {
     categories.forEach((cat) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termsearch",
-  "version": "0.3.14",
+  "version": "0.3.15",
   "description": "Personal search engine for Termux/Linux/macOS — zero-config, privacy-first, AI-optional",
   "type": "module",
   "bin": {

package/src/ai/query.js

@@ -2,6 +2,25 @@
 
 import { call } from './providers/openai-compat.js';
 
+// Fast regex-based torrent intent detection (no AI call needed)
+export const TORRENT_QUERY_RE = /\b(torrent|magnet|\.iso|\.mkv|\.avi|\.mp4|720p|1080p|2160p|4k|uhd|season|s\d{1,2}e\d{1,2}|xvid|x264|x265|hevc|blu.?ray|webrip|dvdrip|bdrip|hdtv|yify|yts|piratebay|1337x|nyaa|eztv|tgx|download\s+film|download\s+serie|scarica\s+film)\b/i;
+
+// Available engine names for also_search_on routing
+const ENGINE_ROUTING_RULES = `
+Engine routing rules — pick from this list only:
+- Code, libraries, APIs, "how to implement", programming → ["github-api", "duckduckgo", "hackernews"]
+- Opinions, reviews, "best X", community advice → ["reddit", "duckduckgo"]
+- Academic papers, research, studies, citations → ["wikidata", "duckduckgo"]
+- Open source, FOSS, privacy tools → ["github-api", "marginalia", "duckduckgo"]
+- Person/brand social presence → ["reddit", "duckduckgo"]
+- Anime, manga, Japanese content → ["nyaa", "duckduckgo"]
+- TV shows, episodes → ["eztv", "duckduckgo"]
+- Movies, film downloads → ["yts", "piratebay", "duckduckgo"]
+- General torrent/file downloads → ["piratebay", "1337x", "tgx"]
+- News, current events → ["duckduckgo", "hackernews"]
+- Definitions, encyclopedic → ["wikipedia", "duckduckgo"]
+- Default/other → ["duckduckgo", "startpage"]`;
+
 function buildQueryInterpretPrompt({ query, lang }) {
   const langName = {
     'it-IT': 'Italian', 'en-US': 'English', 'es-ES': 'Spanish',
@@ -16,18 +35,21 @@ User language: ${langName}
 Respond with this exact JSON structure:
 {
   "refined_query": "improved version of the query (or same if already good)",
-  "intent": "one of: definition, how_to, news, research, comparison, navigation, other",
-  "also_search": ["optional alternative query 1", "optional alternative query 2"]
+  "intent": "one of: torrent, code, social, academic, news, definition, how_to, other",
+  "also_search_on": ["engine1", "engine2"],
+  "category": "one of: web, torrent, images, news"
 }
+${ENGINE_ROUTING_RULES}
 
 Rules:
-- refined_query: fix typos, expand acronyms, clarify ambiguous terms — keep it concise
-- intent: classify what the user is looking for
-- also_search: at most 2 useful variant queries, empty array if not applicable
+- refined_query: fix typos, expand acronyms — keep concise
+- intent: classify the query type
+- also_search_on: 2-3 engine names from the routing rules above, best match for this query
+- category: "torrent" if the query is clearly about downloading files/media, else "web"
 - JSON only, no explanation`;
 }
 
-// Returns { refined_query, intent, also_search } or null on failure
+// Returns { refined_query, intent, also_search_on, category } or null on failure
 export async function refineQuery({ query, lang = 'en-US' }, aiConfig) {
   if (!aiConfig?.enabled || !aiConfig?.api_base || !aiConfig?.model) return null;
 
@@ -43,10 +65,21 @@ export async function refineQuery({ query, lang = 'en-US' }, aiConfig) {
 
     if (!result?.content) return null;
     const parsed = JSON.parse(result.content);
+
+    const ALLOWED_ENGINES = new Set([
+      'duckduckgo', 'wikipedia', 'startpage', 'qwant', 'ecosia', 'brave', 'mojeek',
+      'github', 'github-api', 'hackernews', 'reddit', 'yandex', 'marginalia', 'ahmia',
+      'piratebay', '1337x', 'yts', 'nyaa', 'eztv', 'tgx',
+      'wikidata', 'youtube', 'mastodon users', 'lemmy posts',
+    ]);
+
     return {
-      refined_query: String(parsed.refined_query || query).slice(0, 240),
-      intent: String(parsed.intent || 'other'),
-      also_search: Array.isArray(parsed.also_search) ? parsed.also_search.slice(0, 2).map(String) : [],
+      refined_query:  String(parsed.refined_query || query).slice(0, 240),
+      intent:         String(parsed.intent || 'other'),
+      also_search_on: Array.isArray(parsed.also_search_on)
+        ? parsed.also_search_on.map(String).filter(e => ALLOWED_ENGINES.has(e)).slice(0, 3)
+        : [],
+      category: ['web', 'torrent', 'images', 'news'].includes(parsed.category) ? parsed.category : 'web',
     };
   } catch {
     return null;

package/src/api/routes.js

@@ -12,7 +12,7 @@ import { sendJson, sendRateLimited, applySecurityHeaders } from './middleware.js
 import { getStatus as autostartStatus, setEnabled as autostartSetEnabled } from '../autostart/manager.js';
 import { detectProfileTarget, scanProfile, PROFILER_PLATFORMS } from '../profiler/scanner.js';
 import { fetchBlueskyPosts, fetchBlueskyActors, fetchGdeltArticles } from '../social/search.js';
-import { scrapeTPB, scrape1337x, extractMagnetFromUrl } from '../torrent/scrapers.js';
+import { scrapeTPB, scrape1337x, scrapeYTS, scrapeNyaa, scrapeEZTV, scrapeTGx, extractMagnetFromUrl } from '../torrent/scrapers.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -25,7 +25,7 @@ const APP_VERSION = (() => {
     return '0.0.0';
   }
 })();
-const ALLOWED_CATEGORIES = new Set(['web', 'images', 'news']);
+const ALLOWED_CATEGORIES = new Set(['web', 'images', 'news', 'torrent']);
 const ALLOWED_LANGS = new Set(['auto', 'it-IT', 'en-US', 'es-ES', 'fr-FR', 'de-DE', 'pt-PT', 'ru-RU', 'zh-CN', 'ja-JP']);
 
 function parseCategory(raw) {
@@ -393,15 +393,15 @@ export function createRouter(config, rateLimiters) {
     }
 
     const cfg = config.getConfig();
-    if (!cfg.ai?.enabled) return sendJson(res, 200, { refined_query: req.body?.query, intent: 'other', also_search: [] });
-
     const query = String(req.body?.query || '').trim();
     const lang = resolveLang(req.body?.lang, req.headers['accept-language']);
     if (!query) return sendJson(res, 400, { error: 'missing_query' });
 
+    if (!cfg.ai?.enabled) return sendJson(res, 200, { refined_query: query, intent: 'other', also_search_on: [], category: 'web' });
+
     const result = await refineQuery({ query, lang }, cfg.ai);
     applySecurityHeaders(res);
-    res.json(result || { refined_query: query, intent: 'other', also_search: [] });
+    res.json(result || { refined_query: query, intent: 'other', also_search_on: [], category: 'web' });
   });
 
   // ─── AI summary (SSE streaming) ────────────────────────────────────────────
@@ -482,7 +482,7 @@ export function createRouter(config, rateLimiters) {
       return sendJson(res, 400, { error: 'invalid_body' });
     }
     // Whitelist accepted config keys to prevent unexpected writes
-    const allowed = ['port', 'host', 'ai', 'brave', 'mojeek', 'yandex', 'ahmia', 'marginalia', 'searxng', 'search', 'rate_limit'];
+    const allowed = ['port', 'host', 'ai', 'brave', 'mojeek', 'startpage', 'qwant', 'ecosia', 'yandex', 'ahmia', 'marginalia', 'searxng', 'search', 'rate_limit'];
     const filtered = {};
     for (const key of allowed) {
       if (key in body) filtered[key] = body[key];
@@ -637,13 +637,30 @@ export function createRouter(config, rateLimiters) {
     const query = String(req.body?.q || req.body?.query || '').trim().slice(0, 200);
     if (!query) return sendJson(res, 400, { error: 'missing_query', message: 'q required' });
     try {
-      const [tpb, lxx] = await Promise.allSettled([scrapeTPB(query, 8), scrape1337x(query, 7)]);
-      const results = [
-        ...(tpb.status === 'fulfilled' ? tpb.value : []),
-        ...(lxx.status === 'fulfilled' ? lxx.value : []),
+      const [tpb, lxx, yts, nyaa, eztv, tgx] = await Promise.allSettled([
+        scrapeTPB(query, 8),
+        scrape1337x(query, 6),
+        scrapeYTS(query, 6),
+        scrapeNyaa(query, 6),
+        scrapeEZTV(query, 6),
+        scrapeTGx(query, 6),
+      ]);
+      const all = [
+        ...(tpb.status  === 'fulfilled' ? tpb.value  : []),
+        ...(lxx.status  === 'fulfilled' ? lxx.value  : []),
+        ...(yts.status  === 'fulfilled' ? yts.value  : []),
+        ...(nyaa.status === 'fulfilled' ? nyaa.value : []),
+        ...(eztv.status === 'fulfilled' ? eztv.value : []),
+        ...(tgx.status  === 'fulfilled' ? tgx.value  : []),
       ];
+      // Deduplicate by magnet hash, sort by seeds desc
+      const seen = new Set();
+      const results = all
+        .filter((r) => { const h = r.magnetLink?.match(/btih:([a-f0-9]+)/i)?.[1]?.toLowerCase(); if (!h || seen.has(h)) return false; seen.add(h); return true; })
+        .sort((a, b) => (b.seed || 0) - (a.seed || 0));
+      const sources = [...new Set(results.map((r) => r.engine))];
       applySecurityHeaders(res);
-      res.json({ results, source: results.length ? 'tpb+1337x' : 'none' });
+      res.json({ results, source: sources.join('+') || 'none' });
     } catch (error) {
       sendJson(res, 502, { error: 'scrape_failed', message: error.message });
     }

package/src/search/engine.js

@@ -55,8 +55,10 @@ export const ALLOWED_ENGINES = new Set([
   '1337x',
   'piratebay',
   'nyaa',
+  'yts',
+  'eztv',
+  'tgx',
   // native scrapers
-  'startpage',
   'qwant',
   'ecosia',
   // uncensored / alternative index engines
@@ -611,6 +613,9 @@ export async function* searchStream({ query, lang = 'en-US', safe = '1', page =
 
 export function getEnabledProviders(cfg) {
   const providers = ['duckduckgo', 'wikipedia'];
+  if (cfg?.startpage?.enabled !== false) providers.push('startpage');
+  if (cfg?.qwant?.enabled !== false) providers.push('qwant');
+  if (cfg?.ecosia?.enabled !== false) providers.push('ecosia');
   if (cfg.brave?.enabled && cfg.brave?.api_key) providers.push('brave');
   if (cfg.mojeek?.enabled && cfg.mojeek?.api_key) providers.push('mojeek');
   if (cfg.searxng?.enabled && cfg.searxng?.url) providers.push('searxng');

package/src/search/ranking.js

@@ -2,18 +2,41 @@
 
 // Source quality weights — higher = results from this source ranked first
 const SOURCE_ENGINE_WEIGHTS = {
-  'wikipedia':    1.8,
+  // Reference sources
+  'wikipedia':     1.8,
   'wikipedia-api': 1.8,
-  'brave-api':    1.5,
-  'mojeek-api':   1.4,
-  'duckduckgo':   1.2,
-  'searxng':      1.1,
-  // engines from SearXNG
-  'startpage':    1.3,
-  'qwant':        1.2,
-  'bing':         1.1,
-  'google':       1.1,
-  'yahoo':        1.0,
+  'wikidata':      1.6,
+  // Paid API providers
+  'brave-api':     1.5,
+  'mojeek-api':    1.4,
+  'mojeek':        1.3,
+  // Native zero-config scrapers
+  'startpage':     1.35,
+  'qwant':         1.3,
+  'ecosia':        1.2,
+  'duckduckgo':    1.2,
+  // Alternative/uncensored
+  'yandex':        1.15,
+  'marginalia':    1.1,
+  'ahmia':         1.0,
+  // SearXNG-routed
+  'searxng':       1.1,
+  'bing':          1.1,
+  'google':        1.1,
+  'yahoo':         1.0,
+  // Dev/code
+  'github':        1.25,
+  'github-api':    1.3,
+  'hackernews':    1.15,
+  // Social
+  'reddit':        1.1,
+  // Torrent (rank by seeds, not source quality)
+  'piratebay':     1.0,
+  '1337x':         1.0,
+  'yts':           1.0,
+  'nyaa':          1.0,
+  'eztv':          1.0,
+  'tgx':           1.0,
 };
 
 function getSourceWeight(engine) {

package/src/torrent/scrapers.js

@@ -1,5 +1,5 @@
-// Torrent scrapers — ported from MmmSearch
-// Sources: The Pirate Bay + 1337x (direct HTML scraping, no API)
+// Torrent scrapers — multi-source, no API keys required
+// Sources: TPB, 1337x, YTS (JSON API), Nyaa, EZTV (API), Torrent Galaxy
 
 import { assertPublicUrl } from '../fetch/ssrf-guard.js';
 
@@ -114,6 +114,133 @@ export async function scrape1337x(query, limit = 5) {
   return [];
 }
 
+// ─── YTS (YIFY) ───────────────────────────────────────────────────────────────
+// Public JSON API — movies only, high-quality releases, direct magnets
+
+export async function scrapeYTS(query, limit = 8) {
+  const params = new URLSearchParams({ query_term: query, limit: String(limit), sort_by: 'seeds', order_by: 'desc' });
+  try {
+    const html = await fetchTorrentPage(`https://yts.mx/api/v2/list_movies.json?${params}`, 10_000);
+    const data = JSON.parse(html);
+    const movies = data?.data?.movies || [];
+    const results = [];
+    for (const movie of movies) {
+      for (const torrent of (movie.torrents || []).slice(0, 2)) {
+        const hash = torrent.hash;
+        if (!hash) continue;
+        const magnet = `magnet:?xt=urn:btih:${hash}&dn=${encodeURIComponent(movie.title_long)}&tr=udp%3A%2F%2Ftracker.opentrackr.org%3A1337%2Fannounce&tr=udp%3A%2F%2Fopen.tracker.cl%3A1337%2Fannounce`;
+        results.push({
+          title:     `${movie.title_long} [${torrent.quality}] [${torrent.type || 'web'}]`,
+          url:       movie.url || `https://yts.mx/movies/${movie.slug}`,
+          magnetLink: magnet,
+          seed:      torrent.seeds || 0,
+          leech:     torrent.peers || 0,
+          engine:    'yts',
+          filesize:  torrent.size || null,
+        });
+        if (results.length >= limit) break;
+      }
+      if (results.length >= limit) break;
+    }
+    return results;
+  } catch { return []; }
+}
+
+// ─── Nyaa ─────────────────────────────────────────────────────────────────────
+// Anime/manga/JP content — simple table HTML, magnets inline
+
+const NYAA_MIRRORS = [
+  'https://nyaa.si',
+  'https://nyaa.land',
+];
+
+export async function scrapeNyaa(query, limit = 8) {
+  const slug = encodeURIComponent(query.trim());
+  for (const base of NYAA_MIRRORS) {
+    try {
+      const html = await fetchTorrentPage(`${base}/?q=${slug}&s=seeders&o=desc`, 12_000);
+      if (html.includes('Cloudflare') || html.includes('cf-browser-verification')) continue;
+      const rows = html.split(/<tr[\s>]/gi).slice(1);
+      const results = [];
+      for (const row of rows) {
+        if (results.length >= limit) break;
+        const magnetM = row.match(/href="(magnet:\?xt=urn:btih:[^"]{20,}?)"/i);
+        if (!magnetM) continue;
+        const titleM = row.match(/title="([^"]{3,200})"/i) || row.match(/class="[^"]*success[^"]*"[^>]*>\s*<[^>]+>([^<]{3,200})<\/a>/i);
+        const seedM  = row.match(/<td[^>]*class="[^"]*success[^"]*"[^>]*>\s*(\d+)\s*<\/td>/i);
+        const leechM = row.match(/<td[^>]*class="[^"]*danger[^"]*"[^>]*>\s*(\d+)\s*<\/td>/i);
+        const title  = titleM ? titleM[1].trim() : 'Unknown';
+        results.push({
+          title, url: '', magnetLink: magnetM[1],
+          seed:  seedM  ? parseInt(seedM[1],  10) : 0,
+          leech: leechM ? parseInt(leechM[1], 10) : 0,
+          engine: 'nyaa',
+        });
+      }
+      if (results.length > 0) return results;
+    } catch { /* next mirror */ }
+  }
+  return [];
+}
+
+// ─── EZTV ─────────────────────────────────────────────────────────────────────
+// TV shows — JSON API, direct magnets
+
+export async function scrapeEZTV(query, limit = 8) {
+  const params = new URLSearchParams({ limit: String(limit), page: '1', q: query });
+  try {
+    const html = await fetchTorrentPage(`https://eztv.re/api/get-torrents?${params}`, 10_000);
+    const data = JSON.parse(html);
+    const torrents = data?.torrents || [];
+    return torrents.slice(0, limit).map((t) => ({
+      title:     t.title || t.filename || 'Unknown',
+      url:       t.episode_url || '',
+      magnetLink: t.magnet_url || '',
+      seed:      t.seeds  || 0,
+      leech:     t.peers  || 0,
+      engine:    'eztv',
+      filesize:  t.size_bytes ? `${(t.size_bytes / 1_073_741_824).toFixed(2)} GB` : null,
+    })).filter((r) => r.magnetLink);
+  } catch { return []; }
+}
+
+// ─── Torrent Galaxy (TGx) ─────────────────────────────────────────────────────
+// General index — HTML scraping, good for software/movies/games
+
+const TGX_MIRRORS = [
+  'https://torrentgalaxy.to',
+  'https://tgx.rs',
+];
+
+export async function scrapeTGx(query, limit = 6) {
+  const slug = encodeURIComponent(query.trim());
+  for (const base of TGX_MIRRORS) {
+    try {
+      const html = await fetchTorrentPage(`${base}/torrents.php?search=${slug}&sort=seeders&order=desc`, 14_000);
+      if (html.includes('Cloudflare') || html.length < 2000) continue;
+
+      const rows = html.split(/<div[^>]+class="[^"]*tgxtablerow[^"]*"/gi).slice(1);
+      const results = [];
+      for (const row of rows) {
+        if (results.length >= limit) break;
+        const magnetM = row.match(/href="(magnet:\?xt=urn:btih:[^"]{20,}?)"/i);
+        if (!magnetM) continue;
+        const titleM = row.match(/href="\/torrent\/\d+\/([^"]+)"[^>]*class="[^"]*txlight[^"]*"/i)
+          || row.match(/title="([^"]{3,200})"/i);
+        const seedM  = row.match(/<span[^>]*class="[^"]*tgxtable-s[^"]*"[^>]*>\s*(\d+)\s*<\/span>/i);
+        const title  = titleM ? decodeURIComponent(titleM[1].replace(/\+/g, ' ')).trim() : 'Unknown';
+        results.push({
+          title, url: '', magnetLink: magnetM[1],
+          seed:  seedM ? parseInt(seedM[1], 10) : 0,
+          leech: 0, engine: 'tgx',
+        });
+      }
+      if (results.length > 0) return results;
+    } catch { /* next mirror */ }
+  }
+  return [];
+}
+
 // ─── Magnet extraction from URL ───────────────────────────────────────────────
 
 export async function extractMagnetFromUrl(rawUrl) {