ani-auto 1.3.2 → 1.4.1

package/.qwen/settings.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm install *)",
+      "Bash(npm cache *)"
+    ]
+  },
+  "$version": 3
+}

package/README.md

@@ -117,6 +117,8 @@ ani-auto daemon install
 **other daemon commands:**
 
 ```bash
+ani-auto daemon enable   # enable daemon service
+ani-auto daemon disable  # disable daemon service
 ani-auto daemon start    # start the service
 ani-auto daemon stop     # stop the service
 ani-auto daemon restart  # restart the service

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "ani-auto",
-  "version": "1.3.2",
-  "description": "Automatic anime episode downloader",
+  "version": "1.4.1",
+  "description": "automatic anime episode downloader",
   "bin": {
-    "ani-auto": "./src/cli.js"
+    "ani-auto": "src/cli.js"
   },
   "scripts": {
     "start": "node src/daemon.js",
@@ -17,6 +17,9 @@
     "inquirer": "^8.2.6",
     "node-fetch": "^2.7.0",
     "ora": "^5.4.1",
+    "puppeteer": "^24.40.0",
+    "puppeteer-extra": "^3.3.6",
+    "puppeteer-extra-plugin-stealth": "^2.11.2",
     "sql.js": "^1.12.0"
   }
 }

package/src/anilist.js

@@ -4,8 +4,6 @@ const fetch = require('node-fetch');
 
 const ANILIST_GQL = 'https://graphql.anilist.co';
 
-// ── Queries ────────────────────────────────────────────────────────────────
-
 const MEDIA_LIST_QUERY = `
 query ($userName: String, $status: MediaListStatus) {
     MediaListCollection(userName: $userName, type: ANIME, status: $status) {
@@ -45,30 +43,23 @@ query ($search: String) {
     }
 }`;
 
-// ── Helpers ────────────────────────────────────────────────────────────────
-
 async function gqlRequest(query, variables = {}, token = null) {
     const headers = { 'Content-Type': 'application/json', 'Accept': 'application/json' };
     if (token) headers['Authorization'] = `Bearer ${token}`;
-
     const res = await fetch(ANILIST_GQL, {
         method: 'POST',
         headers,
         body: JSON.stringify({ query, variables }),
     });
-
     if (!res.ok) {
         const text = await res.text();
         throw new Error(`AniList API error ${res.status}: ${text}`);
     }
-
     const json = await res.json();
     if (json.errors) throw new Error(`AniList GQL error: ${json.errors[0].message}`);
     return json.data;
 }
 
-// ── Public API ─────────────────────────────────────────────────────────────
-
 async function getViewer(token) {
     const data = await gqlRequest(VIEWER_QUERY, {}, token);
     return data.Viewer;
@@ -77,7 +68,7 @@ async function getViewer(token) {
 async function getUserList(userName, statuses, token = null) {
     const results = [];
     for (const status of statuses) {
-        const data = await gqlRequest(MEDIA_LIST_QUERY, { userName, status }, token);
+        const data  = await gqlRequest(MEDIA_LIST_QUERY, { userName, status }, token);
         const lists = data?.MediaListCollection?.lists || [];
         for (const list of lists) {
             for (const entry of list.entries) {
@@ -100,10 +91,6 @@ async function getUserList(userName, statuses, token = null) {
     return results;
 }
 
-/**
- * Search AniList for anime by title.
- * Returns up to 8 results with id, titles, episodes, status, year.
- */
 async function searchAnime(query, token = null) {
     const data = await gqlRequest(SEARCH_QUERY, { search: query }, token);
     return (data?.Page?.media || []).map(m => ({
@@ -113,10 +100,10 @@ async function searchAnime(query, token = null) {
             english: m.title.english,
             native:  m.title.native,
         },
-        episodes:  m.episodes,
-        status:    m.status,
-        year:      m.seasonYear,
-        format:    m.format,
+        episodes: m.episodes,
+        status:   m.status,
+        year:     m.seasonYear,
+        format:   m.format,
     }));
 }
 
@@ -124,9 +111,4 @@ function pickTitle(titles) {
     return titles.english || titles.romaji || titles.native;
 }
 
-module.exports = {
-    getViewer,
-    getUserList,
-    searchAnime,
-    pickTitle,
-};
+module.exports = { getViewer, getUserList, searchAnime, pickTitle };

package/src/cli.js

@@ -681,7 +681,7 @@ program
 
 program
     .command('daemon [action]')
-    .description('Manage the background daemon (install, start, stop, restart, status, logs)')
+    .description('Manage the background daemon (install, start, stop, restart, status, logs, enable, disable)')
     .action(async (action) => {
         const { spawnSync, spawn } = require('child_process');
         const SERVICE = 'ani-auto';
@@ -731,6 +731,11 @@ program
                 break;
             }
             case 'start': {
+                const cfgStart = loadConfig();
+                if (cfgStart.daemonEnabled === false) {
+                    console.log(chalk.red('\n  ✖  daemon is not enabled — run ani-auto daemon enable first\n'));
+                    break;
+                }
                 const r = run(`systemctl --user start ${SERVICE}`);
                 if (r.code === 0) console.log(chalk.green('\n  Done  Daemon started.\n'));
                 else console.log(chalk.red(`\n  Failed to start: ${r.err}\n  Try: ani-auto daemon install\n`));
@@ -743,12 +748,20 @@ program
                 break;
             }
             case 'restart': {
+                const cfgRestart = loadConfig();
+                if (cfgRestart.daemonEnabled === false) {
+                    console.log(chalk.red('\n  ✖  daemon is not enabled — run ani-auto daemon enable first\n'));
+                    break;
+                }
                 const r = run(`systemctl --user restart ${SERVICE}`);
                 if (r.code === 0) console.log(chalk.green('\n  Done  Daemon restarted.\n'));
                 else console.log(chalk.red(`\n  Failed to restart: ${r.err}\n`));
                 break;
             }
             case 'status': {
+                const config  = loadConfig();
+                const enabled = config.daemonEnabled !== false;
+                console.log(`\n  Daemon downloads: ${enabled ? chalk.green('enabled') : chalk.red('disabled')}`);
                 const r = run(`systemctl --user status ${SERVICE}`);
                 console.log(r.out || r.err);
                 break;
@@ -758,8 +771,38 @@ program
                 spawn('journalctl', ['--user', '-u', SERVICE, '-f'], { stdio: 'inherit' });
                 break;
             }
+
+            // ── New: enable / disable daemon ──────────────────────────────
+            case 'enable': {
+                banner();
+                updateConfig({ daemonEnabled: true });
+                console.log(chalk.green('\n  Done  Daemon enabled.'));
+                console.log(chalk.gray('  Starting systemd service...\n'));
+                const re = run(`systemctl --user start ${SERVICE}`);
+                if (re.code === 0) {
+                    console.log(chalk.green('  Daemon is now running.\n'));
+                } else {
+                    console.log(chalk.yellow('  Could not start systemd service (is it installed?).'));
+                    console.log(chalk.gray(`  Run ${chalk.bold('ani-auto daemon install')} first, or start manually.\n`));
+                }
+                break;
+            }
+            case 'disable': {
+                banner();
+                updateConfig({ daemonEnabled: false });
+                console.log(chalk.yellow('\n  Done  Daemon disabled.'));
+                console.log(chalk.gray('  Stopping systemd service...\n'));
+                run(`systemctl --user stop ${SERVICE}`);
+                console.log(chalk.gray(
+                    '  The service is stopped and will exit immediately on any future\n' +
+                    '  startup (boot, network restore, manual start) until re-enabled.\n'
+                ));
+                console.log(`  To re-enable: ${chalk.bold('ani-auto daemon enable')}\n`);
+                break;
+            }
+
             default:
-                console.log(chalk.yellow(`\n  Unknown action "${action}". Use: install, start, stop, restart, status, logs\n`));
+                console.log(chalk.yellow(`\n  Unknown action "${action}". Use: install, start, stop, restart, status, logs, enable, disable\n`));
         }
     });
 

package/src/cloudflare.js

@@ -0,0 +1,91 @@
+'use strict';
+
+const puppeteer = require('puppeteer-extra');
+const StealthPlugin = require('puppeteer-extra-plugin-stealth');
+puppeteer.use(StealthPlugin());
+
+const chalk = require('chalk');
+
+let cachedCookie = null;
+let cachedAt = null;
+const COOKIE_TTL_MS = 30 * 60 * 1000; // 30 minutes
+
+function log(msg) {
+    const ts = new Date().toISOString().replace('T', ' ').slice(0, 19);
+    console.log(`${chalk.gray(ts)} ${chalk.magenta('☁')}  ${msg}`);
+}
+
+async function solveCloudflare(downloadUrl) {
+    log('Launching browser to solve Cloudflare challenge...');
+    const browser = await puppeteer.launch({
+        headless: 'new',
+        args: [
+            '--no-sandbox',
+            '--disable-setuid-sandbox',
+            '--disable-blink-features=AutomationControlled',
+        ],
+    });
+    const page = await browser.newPage();
+
+    await page.setViewport({ width: 1920, height: 1080 });
+    await page.setUserAgent(
+        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+    );
+
+    try {
+        // Navigate to the download URL — Cloudflare should intercept with challenge
+        log(`Navigating to ${new URL(downloadUrl).hostname}...`);
+        await page.goto(downloadUrl, { waitUntil: 'domcontentloaded', timeout: 60000 }).catch(() => {});
+
+        // Poll for cf_clearance cookie — Turnstile auto-solves in ~10-30s
+        const challengeTimeout = 60000;
+        const pollInterval = 2000;
+        let cookie = null;
+        const startTime = Date.now();
+
+        while (Date.now() - startTime < challengeTimeout) {
+            const cookies = await page.cookies();
+            cookie = cookies.find(c => c.name === 'cf_clearance');
+            if (cookie) {
+                log('cf_clearance cookie found!');
+                break;
+            }
+            log('Waiting for Turnstile to solve...');
+            await new Promise(r => setTimeout(r, pollInterval));
+        }
+
+        if (!cookie) {
+            // Take a screenshot for debugging
+            const ssPath = '/tmp/cf_debug.png';
+            await page.screenshot({ path: ssPath });
+            log(`Screenshot saved to ${ssPath}`);
+            throw new Error('cf_clearance cookie not found — challenge may have failed');
+        }
+
+        cachedCookie = cookie.value;
+        cachedAt = Date.now();
+        log('Got cf_clearance cookie (valid ~30 min).');
+        return cookie.value;
+    } finally {
+        await browser.close();
+    }
+}
+
+async function getCachedCookie(url) {
+    // Check if cached cookie is still valid
+    if (cachedCookie && cachedAt && (Date.now() - cachedAt) < COOKIE_TTL_MS) {
+        log('Using cached cf_clearance cookie.');
+        return cachedCookie;
+    }
+    // Expired or missing — solve again
+    if (cachedCookie) log('Cookie expired, re-solving Cloudflare challenge...');
+    return solveCloudflare(url);
+}
+
+function invalidateCache() {
+    cachedCookie = null;
+    cachedAt = null;
+    log('Cache invalidated.');
+}
+
+module.exports = { getCachedCookie, invalidateCache, solveCloudflare };

package/src/config.js

@@ -13,16 +13,18 @@ const DEFAULTS = {
     watchStatuses:         ['CURRENT'],
     manualList:            [],
     quality:               '1080p',
-    language:              'sub',        
+    language:              'sub',
     concurrency:           2,
     outputDir:             path.join(os.homedir(), 'anime'),
     maxRetries:            3,
     daemonIntervalMinutes: 120,
     skipExisting:          true,
     maxEpisodesPerRun:     50,
-    telegramChatId:        null,         
-    telegramNotify:        true,         
-    airingBufferMinutes:   5,            // minutes after air time before checking AnimePahe
+    telegramChatId:        null,
+    telegramNotify:        true,
+    airingBufferMinutes:   5,
+    daemonEnabled:         true,         // set to false via `ani-auto daemon disable`
+    apiBaseUrl:            'https://aor-rex-anikuro-api.hf.space',
 };
 
 function ensureConfigDir() {

package/src/daemon.js

@@ -13,7 +13,6 @@ let running = false;
 
 function ts() { return new Date().toISOString().replace('T', ' ').slice(0, 19); }
 
-function log(msg)  { console.log(`${chalk.gray(ts())} ${msg}`); }
 function info(msg) { console.log(`${chalk.gray(ts())} ${chalk.cyan('ℹ')}  ${msg}`); }
 function warn(msg) { console.log(`${chalk.gray(ts())} ${chalk.yellow('⚠')}  ${msg}`); }
 
@@ -85,8 +84,18 @@ async function scheduleSmartChecks() {
 // ── Startup ────────────────────────────────────────────────────────────────
 
 async function startDaemon() {
-    const config       = loadConfig();
-    const intervalMs   = (config.daemonIntervalMinutes || 30) * 60 * 1000;
+    const config = loadConfig();
+
+    // ── Enabled gate ──────────────────────────────────────────────────────
+    if (config.daemonEnabled === false) {
+        process.stderr.write(chalk.red(`\n  ✖  [${ts()}] error: daemon is disabled\n`));
+        process.stderr.write(chalk.gray(`  startup blocked — daemon was disabled via 'ani-auto daemon disable'\n`));
+        process.stderr.write(chalk.gray(`  this applies to all startups: boot, network restore, and manual start\n`));
+        process.stderr.write(`\n  to re-enable: ${chalk.bold.cyan('ani-auto daemon enable')}\n\n`);
+        process.exit(1);
+    }
+
+    const intervalMs = (config.daemonIntervalMinutes || 30) * 60 * 1000;
 
     console.log(chalk.bold.red(`
    █████╗ ███╗   ██╗██╗      █████╗ ██╗   ██╗████████╗ ██████╗ 
@@ -127,7 +136,6 @@ async function startDaemon() {
         await scheduleSmartChecks(); // Refresh smart timers each interval
     }, intervalMs);
 
-
     console.log(chalk.green(`  Daemon running. Press Ctrl+C to stop.\n`));
 
     process.on('SIGINT', async () => {

package/src/db.js

@@ -1,10 +1,5 @@
 'use strict';
 
-/**
- * db.js — SQLite state layer using sql.js (pure WASM, no native compilation).
- * Drop-in replacement for the better-sqlite3 version.
- * Compatible with Node v25+ without any C++ compilation.
- */
 
 const fs   = require('fs');
 const path = require('path');
@@ -15,9 +10,6 @@ const DB_PATH = path.join(DB_DIR, 'state.db');
 
 let _db = null;
 
-/**
- * Async init — call once at startup before any DB operations.
- */
 async function initDb() {
     if (_db) return _db;
 
@@ -75,8 +67,7 @@ function migrate(db) {
             UNIQUE(anime_id, episode_num)
         )
     `);
-    // Add confirmed_site columns if upgrading from older DB
-    try { db.run('ALTER TABLE anime ADD COLUMN confirmed_site_id TEXT'); } catch(e) {}
+      try { db.run('ALTER TABLE anime ADD COLUMN confirmed_site_id TEXT'); } catch(e) {}
     try { db.run('ALTER TABLE anime ADD COLUMN confirmed_site_title TEXT'); } catch(e) {}
     try { db.run('ALTER TABLE anime ADD COLUMN anilist_title TEXT'); } catch(e) {}
     try { db.run('ALTER TABLE anime ADD COLUMN poster_url TEXT'); } catch(e) {}
@@ -95,7 +86,6 @@ function migrate(db) {
     `);
 }
 
-// ── Helpers ────────────────────────────────────────────────────────────────
 
 function _assertReady() {
     if (!_db) throw new Error('DB not initialised — call initDb() first at startup.');
@@ -126,7 +116,6 @@ function _run(sql, params = []) {
     _save();
 }
 
-// ── Anime ──────────────────────────────────────────────────────────────────
 
 function upsertAnime({ title, siteId, anilistId, source, quality, language }) {
     _run(`
@@ -167,7 +156,6 @@ function removeAnime(siteId) {
     _run('DELETE FROM anime WHERE id = ?', [row.id]);
 }
 
-// ── Episodes ───────────────────────────────────────────────────────────────
 
 function isEpisodeDownloaded(animeDbId, episodeNum) {
     return !!_get(
@@ -207,7 +195,6 @@ function getEpisodeStats(animeDbId) {
     };
 }
 
-// ── Run log ────────────────────────────────────────────────────────────────
 
 function logRun({ downloaded, skipped, failed, notes }) {
     _run('INSERT INTO run_log (downloaded, skipped, failed, notes) VALUES (?, ?, ?, ?)',

package/src/engine.js

@@ -151,24 +151,41 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
         return { downloaded: 0, skipped: 0, failed: 0 };
     }
 
-    if (existingRow?.confirmed_site_title) {
+    // Priority 1: Match by AniList ID (exact, most reliable)
+    if (workItem.anilistId) {
+        const idMatch = siteResults.find(r => r.anilistId === String(workItem.anilistId));
+        if (idMatch) {
+            siteAnime = idMatch;
+            info(`[${workItem.title}] Matched by AniList ID: ${chalk.bold(siteAnime.title)} (anilist:${siteAnime.anilistId})`);
+            db.saveConfirmedSiteMatch(workItem.title, siteAnime.session, siteAnime.title, siteAnime.poster || null);
+        } else {
+            warn(`[${workItem.title}] AniList ID ${workItem.anilistId} not found in search results — falling back to title match.`);
+        }
+    }
+
+    // Priority 2: Saved site match
+    if (!siteAnime && existingRow?.confirmed_site_title) {
         const savedMatch = siteResults.find(r =>
             r.title?.toLowerCase() === existingRow.confirmed_site_title.toLowerCase()
         ) || siteResults[0];
         siteAnime = savedMatch;
         info(`[${workItem.title}] Using saved site match: ${chalk.bold(siteAnime.title)}`);
         db.saveConfirmedSiteMatch(workItem.title, siteAnime.session, siteAnime.title, siteAnime.poster || null);
-    } else if (auto) {
+    }
+
+    // Priority 3: Auto mode — title matching fallback (no AniList ID, no saved match)
+    if (!siteAnime && auto) {
         const normalize = s => s.toLowerCase().replace(/[^a-z0-9]/g, '');
         const normTitle = normalize(workItem.title);
-        const season    = detectSeason(workItem.title);
         const bestMatch = siteResults.find(r => normalize(r.title) === normTitle)
-            || (season ? siteResults.find(r => detectSeason(r.title) === season) : null)
             || siteResults[0];
         siteAnime = bestMatch;
         db.saveConfirmedSiteMatch(workItem.title, siteAnime.session, siteAnime.title, siteAnime.poster || null);
         info(`[${workItem.title}] Auto-matched to: ${chalk.bold(siteAnime.title)}`);
-    } else {
+    }
+
+    // Priority 4: Interactive mode — user picks
+    if (!siteAnime) {
         const topResults = siteResults.slice(0, 5);
         const { pick } = await inquirer.prompt([{
             type:    'list',
@@ -176,7 +193,7 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
             message: `Site results for "${workItem.title}" — select correct match:`,
             choices: [
                 ...topResults.map(r => ({
-                    name:  `${r.title} ${chalk.gray(`(${r.year || '?'}) — ${r.episodes || '?'} eps`)}`,
+                    name:  `${r.title} ${chalk.gray(`(${r.year || '?'}) — ${r.episodes || '?'} eps`)}${r.anilistId ? chalk.gray(` [AL:${r.anilistId}]`) : ''}`,
                     value: r,
                 })),
                 { name: chalk.yellow('Skip this anime'), value: null },
@@ -275,6 +292,9 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
 
     info(`[${workItem.title}] ${toDownload.length} unwatched episode(s) to download (Q:${q} L:${l}, skipping first ${watched}).`);
 
+    const posterUrl = db.getAnimeBySiteTitle(workItem.title)?.poster_url || null;
+    await notify.notifyDownloadStart(cleanTitle, toDownload.length, q, posterUrl);
+
     const queue       = [...toDownload];
     const results     = { downloaded: 0, skipped: 0, failed: 0 };
     const concurrency = Math.min(config.concurrency || 2, queue.length);
@@ -300,7 +320,7 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
             while (!success && attempts < MAX_RETRIES) {
                 attempts++;
                 try {
-                    const links = await scraper.getDownloadLinks(siteAnime.session, ep.session);
+                    const links = await scraper.getDownloadLinks(siteAnime.session, ep.session, q);
                     const link  = scraper.pickLink(links, q, l);
                     if (!link?.mp4Url) throw new Error('No suitable download link found');
 
@@ -400,4 +420,4 @@ async function runCycle({ auto = false, quality = null, language = null, range =
 
 function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
 
-module.exports = { runCycle, resolveWatchList };
+module.exports = { runCycle, resolveWatchList };

package/src/network.js

@@ -1,63 +1,36 @@
 'use strict';
 
-/**
- * network.js — Real-time network monitor using `ip monitor route`
- * Detects internet connectivity changes instantly via Linux routing events.
- * Falls back to polling if `ip` command is unavailable.
- */
-
 const { spawn } = require('child_process');
 const dns        = require('dns');
 
-// Verify actual internet (not just interface up)
 function checkInternet() {
     return new Promise(resolve => {
         dns.lookup('graphql.anilist.co', err => resolve(!err));
     });
 }
 
-/**
- * Start monitoring network connectivity.
- * @param {object} opts
- * @param {function} opts.onOnline  — called when internet is restored
- * @param {function} opts.onOffline — called when internet drops
- * @returns {function} stop — call to stop monitoring
- */
 function watchNetwork({ onOnline, onOffline } = {}) {
-    let online    = true;
-    let debounce  = null;
-    let stopped   = false;
-    let monitor   = null;
+    let online   = true;
+    let debounce = null;
+    let stopped  = false;
+    let monitor  = null;
+    let pollTimer = null;
 
     const handleChange = async () => {
         if (stopped) return;
         clearTimeout(debounce);
-        // Small debounce — routes can flap during reconnect
         debounce = setTimeout(async () => {
             const nowOnline = await checkInternet();
-            if (nowOnline && !online) {
-                online = true;
-                onOnline?.();
-            } else if (!nowOnline && online) {
-                online = false;
-                onOffline?.();
-            }
+            if (nowOnline && !online) { online = true; onOnline?.(); }
+            else if (!nowOnline && online) { online = false; onOffline?.(); }
         }, 2000);
     };
 
-    // Try `ip monitor route` first (Linux)
     try {
         monitor = spawn('ip', ['monitor', 'route'], { stdio: ['ignore', 'pipe', 'ignore'] });
         monitor.stdout.on('data', handleChange);
-        monitor.on('error', () => startFallback());
+        monitor.on('error', () => { monitor = null; pollTimer = setInterval(handleChange, 10000); });
     } catch (e) {
-        startFallback();
-    }
-
-    // Fallback: poll every 10 seconds if ip monitor unavailable
-    let pollTimer = null;
-    function startFallback() {
-        monitor = null;
         pollTimer = setInterval(handleChange, 10000);
     }
 
@@ -69,18 +42,11 @@ function watchNetwork({ onOnline, onOffline } = {}) {
     };
 }
 
-/**
- * Wait until internet is available.
- * Resolves immediately if already online.
- * @returns {Promise<void>}
- */
 function waitForInternet() {
     return new Promise(resolve => {
         checkInternet().then(online => {
             if (online) return resolve();
-            const stop = watchNetwork({
-                onOnline: () => { stop(); resolve(); }
-            });
+            const stop = watchNetwork({ onOnline: () => { stop(); resolve(); } });
         });
     });
 }

package/src/notify.js

@@ -1,32 +1,26 @@
 'use strict';
 
 const { execSync } = require('child_process');
+const fetch = require('node-fetch');
 const { loadConfig } = require('./config');
 
 const BOT_TOKEN = '8695132702:AAEFDoSL6nkdwDOoz5wmoVkmuhaYa4tNw0o';
 
-// ── Telegram helpers ───────────────────────────────────────────────────────
-
 async function sendTelegram(payload) {
     const config = loadConfig();
     const chatId = config.telegramChatId;
     if (!chatId || config.telegramNotify === false) return;
     try {
-        const fetch = require('node-fetch');
-        const isPhoto = !!payload.photo;
-        const endpoint = isPhoto ? 'sendPhoto' : 'sendMessage';
+        const endpoint = payload.photo ? 'sendPhoto' : 'sendMessage';
         await fetch(`https://api.telegram.org/bot${BOT_TOKEN}/${endpoint}`, {
             method:  'POST',
             headers: { 'Content-Type': 'application/json' },
             body:    JSON.stringify({ chat_id: String(chatId), parse_mode: 'HTML', ...payload }),
+            timeout: 5000,
         });
-    } catch (e) {
-        // silently fail
-    }
+    } catch (e) {}
 }
 
-// ── KDE desktop ────────────────────────────────────────────────────────────
-
 async function sendDesktop(title, body, urgency = 'normal', posterUrl = null) {
     try {
         let icon = '';
@@ -34,7 +28,6 @@ async function sendDesktop(title, body, urgency = 'normal', posterUrl = null) {
             const os    = require('os');
             const path  = require('path');
             const fs    = require('fs');
-            const fetch = require('node-fetch');
             const tmp   = path.join(os.tmpdir(), 'ani-auto-poster.jpg');
             try {
                 const res = await fetch(posterUrl);
@@ -42,35 +35,52 @@ async function sendDesktop(title, body, urgency = 'normal', posterUrl = null) {
                 icon = `-i "${tmp}"`;
             } catch (e) {}
         }
-        execSync(`notify-send -u ${urgency} ${icon} -a "ani-auto" "${title}" "${body}"`, { stdio: 'ignore' });
+        execSync(`notify-send -u ${urgency} ${icon} -a "ani-auto" "${title}" "${body}"`, { stdio: 'ignore', timeout: 5000 });
     } catch (e) {}
 }
 
-// ── Public notification functions ──────────────────────────────────────────
+async function notifyDownloadStart(animeTitle, episodeCount, quality, posterUrl) {
+    const caption =
+        `<b>${animeTitle}</b>\n` +
+        `<code>━━━━━━━━━━━━━━━</code>\n` +
+        `▶  download started\n` +
+        `📥  episodes: ${episodeCount}\n` +
+        `🎞  quality: ${quality || 'default'}`;
+    const p1 = posterUrl
+        ? sendTelegram({ photo: posterUrl, caption })
+        : sendTelegram({ text: caption });
+    const p2 = sendDesktop(
+        animeTitle,
+        `downloading ${episodeCount} episode${episodeCount !== 1 ? 's' : ''} · ${quality || 'default'}`,
+        'normal',
+        posterUrl
+    );
+    await Promise.allSettled([p1, p2]);
+}
 
 async function notifyEpisode(animeTitle, episode, quality, posterUrl) {
     const caption =
         `<b>${animeTitle}</b>\n` +
         `<code>━━━━━━━━━━━━━━━</code>\n` +
-        `✅  Episode ${episode} downloaded\n` +
-        `🎞  Quality: ${quality || 'default'}`;
-
-    if (posterUrl) {
-        await sendTelegram({ photo: posterUrl, caption });
-    } else {
-        await sendTelegram({ text: `🎬 ${caption}` });
-    }
-    await sendDesktop(animeTitle, `Episode ${episode} downloaded`, 'normal', posterUrl);
+        `✅  episode ${episode} downloaded\n` +
+        `🎞  quality: ${quality || 'default'}`;
+    const p1 = posterUrl
+        ? sendTelegram({ photo: posterUrl, caption })
+        : sendTelegram({ text: `🎬 ${caption}` });
+    const p2 = sendDesktop(animeTitle, `episode ${episode} downloaded`, 'normal', posterUrl);
+    await Promise.allSettled([p1, p2]);
 }
 
 async function notifyFailed(animeTitle, episode, error) {
     const text =
         `❌ <b>${animeTitle}</b>\n` +
         `<code>━━━━━━━━━━━━━━━</code>\n` +
-        `Episode ${episode} failed\n` +
+        `episode ${episode} failed\n` +
         `<i>${error}</i>`;
-    await sendTelegram({ text });
-    await sendDesktop(animeTitle, `Episode ${episode} failed`, 'critical');
+    await Promise.allSettled([
+        sendTelegram({ text }),
+        sendDesktop(animeTitle, `episode ${episode} failed`, 'critical')
+    ]);
 }
 
 async function notifySummary(totals) {
@@ -78,11 +88,13 @@ async function notifySummary(totals) {
     const text =
         `📊 <b>ani-auto run complete</b>\n` +
         `<code>━━━━━━━━━━━━━━━</code>\n` +
-        `✅  Downloaded:  ${totals.downloaded}\n` +
-        `⏭   Skipped:     ${totals.skipped}\n` +
-        `❌  Failed:      ${totals.failed}`;
-    await sendTelegram({ text });
-    await sendDesktop('ani-auto run complete', `Downloaded: ${totals.downloaded}  Failed: ${totals.failed}`);
+        `✅  downloaded:  ${totals.downloaded}\n` +
+        `⏭   skipped:     ${totals.skipped}\n` +
+        `❌  failed:      ${totals.failed}`;
+    await Promise.allSettled([
+        sendTelegram({ text }),
+        sendDesktop('ani-auto run complete', `downloaded: ${totals.downloaded}  failed: ${totals.failed}`)
+    ]);
 }
 
 async function notifyDaemonStart(intervalMinutes, downloadingCount) {
@@ -90,25 +102,20 @@ async function notifyDaemonStart(intervalMinutes, downloadingCount) {
     const text =
         `🚀 <b>ani-auto daemon started</b>\n` +
         `<code>━━━━━━━━━━━━━━━</code>\n` +
-        `📦  Version:      v${version}\n` +
-        `📺  Downloading:  ${downloadingCount} anime\n` +
-        `⏱  Fallback check every ${intervalMinutes} minutes`;
-    await sendTelegram({ text });
-    await sendDesktop(
-        `ani-auto v${version} started`,
-        `Downloading ${downloadingCount} anime · every ${intervalMinutes} min`
-    );
+        `📦  version:      v${version}\n` +
+        `📺  downloading:  ${downloadingCount} anime\n` +
+        `⏱  fallback check every ${intervalMinutes} minutes`;
+    await Promise.allSettled([
+        sendTelegram({ text }),
+        sendDesktop(`ani-auto v${version} started`, `downloading ${downloadingCount} anime · every ${intervalMinutes} min`)
+    ]);
 }
 
 async function notifyDaemonStop() {
-    await sendTelegram({ text: '🛑 <b>ani-auto daemon stopped</b>' });
-    await sendDesktop('ani-auto daemon stopped', '');
+    await Promise.allSettled([
+        sendTelegram({ text: '🛑 <b>ani-auto daemon stopped</b>' }),
+        sendDesktop('ani-auto daemon stopped', '')
+    ]);
 }
 
-module.exports = {
-    notifyEpisode,
-    notifyFailed,
-    notifySummary,
-    notifyDaemonStart,
-    notifyDaemonStop,
-};
+module.exports = { notifyDownloadStart, notifyEpisode, notifyFailed, notifySummary, notifyDaemonStart, notifyDaemonStop };

package/src/scraper.js

@@ -1,49 +1,10 @@
 'use strict';
 
-/**
- * scraper.js
- *
- * Thin adapter over the k-anime-cli utils.
- * This is the ONLY file that touches the sister CLI project.
- *
- * Expected peer dependency layout:
- *   ../k-anime/utils.js   ← the existing CLI's utils
- *
- * If you keep ani-auto as a separate repo, set KANIME_UTILS_PATH
- * in your environment or config to point to utils.js.
- */
-
-const path = require('path');
+const path  = require('path');
 const fetch = require('node-fetch');
 
-// ── Resolve the sibling CLI utils ─────────────────────────────────────────
-const UTILS_PATH = process.env.KANIME_UTILS_PATH
-    || path.resolve(__dirname, '../utils.js');
-
-let _utils = null;
-function utils() {
-    if (_utils) return _utils;
-    try {
-        _utils = require(UTILS_PATH);
-    } catch (e) {
-        throw new Error(
-            `Cannot find k-anime utils at "${UTILS_PATH}".\n` +
-            `Set KANIME_UTILS_PATH env var to the correct path.\n` +
-            `Original error: ${e.message}`
-        );
-    }
-    return _utils;
-}
-
-// ── Public surface ────────────────────────────────────────────────────────
+const { SEARCH_API, RELEASES_API, USER_AGENT, downloadFile } = require('../utils');
 
-/**
- * Search the site for an anime by title.
- * Returns the best match or null.
- *
- * @param {string} title
- * @returns {Promise<SiteAnime|null>}
- */
 async function searchAnime(title) {
     const results = await searchAll(title);
     if (!results.length) return null;
@@ -52,88 +13,114 @@ async function searchAnime(title) {
     return exact || results[0];
 }
 
-/** Returns all search results (up to API limit) for user confirmation. */
 async function searchAll(title) {
-    const { SEARCH_API, USER_AGENT } = utils();
-    // Strip special characters that confuse the search API
-    const cleaned = title.replace(/[-–—~:!?()[\]{}<>]/g, ' ').replace(/\s+/g, ' ').trim();
-    const url = `${SEARCH_API}?q=${encodeURIComponent(cleaned)}`;
-    const res = await fetch(url, { headers: { 'User-Agent': USER_AGENT } });
-    if (!res.ok) return [];
-    const data = await res.json();
-    return data.results || [];
+    const cleaned = title.replace(/[-\u2013\u2014~:!?()[\]{}<>]/g, ' ').replace(/\s+/g, ' ').trim().toLowerCase();
+    const trySearch = async (q) => {
+        const res = await fetch(`${SEARCH_API}?q=${encodeURIComponent(q)}`, { headers: { 'User-Agent': USER_AGENT } });
+        if (!res.ok) throw new Error(`Search API returned ${res.status}`);
+        const data = await res.json();
+        const items = Array.isArray(data)
+            ? data
+            : (Array.isArray(data?.data) ? data.data : []);
+
+        const results = items.map(item => ({
+            ...item,
+            session: item.session || item.id,
+            title: item.title,
+            year: item.year,
+            episodes: item.episodes,
+            poster: item.poster,
+            anilistId: null,  // populated below
+        })).filter(item => item.session);
+
+        // Fetch anilistId for each result in parallel (detail endpoint has ids.anilist)
+        await Promise.allSettled(results.map(async (r) => {
+            try {
+                const detailRes = await fetch(`${RELEASES_API}/${encodeURIComponent(r.session)}`, {
+                    headers: { 'User-Agent': USER_AGENT }
+                });
+                if (detailRes.ok) {
+                    const detail = await detailRes.json();
+                    r.anilistId = detail.ids?.anilist ? String(detail.ids.anilist) : null;
+                }
+            } catch {}
+        }));
+
+        return results;
+    };
+    let results = await trySearch(cleaned);
+    if (!results.length && cleaned !== title.toLowerCase()) results = await trySearch(title);
+    return results;
 }
 
-/**
- * Fetch episode list for a given site anime session id.
- *
- * @param {string} animeId  (session field from searchAnime result)
- * @returns {Promise<SiteEpisode[]>}
- */
 async function getEpisodes(animeId) {
-    const { INFO_API, USER_AGENT } = utils();
-    const res = await fetch(`${INFO_API}?id=${animeId}`, { headers: { 'User-Agent': USER_AGENT } });
-    if (!res.ok) throw new Error(`Failed to fetch episode list for ${animeId}`);
-    const data = await res.json();
-    return data.results?.episodes || [];
+    const allEpisodes = [];
+    let page = 1;
+    let lastPage = 1;
+
+    do {
+        const url = page === 1
+            ? `${RELEASES_API}/${encodeURIComponent(animeId)}/releases`
+            : `${RELEASES_API}/${encodeURIComponent(animeId)}/releases?page=${page}`;
+        const res = await fetch(url, { headers: { 'User-Agent': USER_AGENT } });
+        if (!res.ok) throw new Error(`Releases API returned ${res.status} for ${animeId}`);
+        const data = await res.json();
+        lastPage = data.paginationInfo?.lastPage || 1;
+        const items = data.data || [];
+
+        for (const item of items) {
+            const num = Number(item.episode);
+            if (!isNaN(num)) {
+                allEpisodes.push({
+                    episode: num,
+                    session: item.session,
+                    disc: item.disc || null,
+                    audio: item.audio || null,
+                    snapshot: item.snapshot || null,
+                    filler: item.filler || null,
+                    duration: item.duration || null,
+                });
+            }
+        }
+        page++;
+    } while (page <= lastPage);
+
+    return allEpisodes.sort((a, b) => a.episode - b.episode);
 }
 
-/**
- * Fetch download links for a single episode.
- *
- * @param {string} animeId
- * @param {string} episodeId  (session field from episode object)
- * @returns {Promise<DownloadLink[]>}
- */
-async function getDownloadLinks(animeId, episodeId) {
-    const { DOWNLOAD_API, USER_AGENT } = utils();
+async function getDownloadLinks(animeId, session, quality = null) {
     const res = await fetch(
-        `${DOWNLOAD_API}?animeId=${animeId}&episodeId=${episodeId}`,
+        `${RELEASES_API}/${encodeURIComponent(animeId)}/${encodeURIComponent(session)}`,
         { headers: { 'User-Agent': USER_AGENT } }
     );
     if (!res.ok) return [];
     const data = await res.json();
-    return data.results?.downloadLinks || [];
+
+    const sources = data.sources || [];
+    if (!sources.length) return [];
+
+    return sources.map(src => ({
+        mp4Url: src.download || null,
+        resolution: src.resolution || null,
+        isDub: src.isDub || false,
+        fanSub: src.fanSub || null,
+    }));
 }
 
-/**
- * Pick the best download link given quality + language preferences.
- * Falls back gracefully: exact → quality-only → first available.
- *
- * @param {DownloadLink[]} links
- * @param {string} quality   e.g. '1080p'
- * @param {string} language  e.g. 'sub'
- * @returns {DownloadLink|null}
- */
 function pickLink(links, quality, language) {
     if (!links.length) return null;
+    const wantDub = language === 'dub';
+    const targetRes = quality.replace('p', '');  // "1080p" → "1080"
     return (
-        links.find(l => l.resolution === quality && l.audio === language) ||
-        links.find(l => l.resolution === quality) ||
+        links.find(l => l.resolution === targetRes && l.isDub === wantDub) ||
+        links.find(l => l.resolution === targetRes) ||
+        links.find(l => l.isDub === wantDub) ||
         links[0]
     );
 }
 
-/**
- * Download a single episode file.
- * Delegates entirely to the existing CLI's downloadFile().
- *
- * @param {string} url
- * @param {string} filename
- * @param {string} outputDir
- * @param {*}      multiBar   cliProgress.MultiBar instance (or null for silent)
- * @param {number} episodeNum
- */
 async function downloadEpisode(url, filename, outputDir, multiBar, episodeNum) {
-    const { downloadFile } = utils();
     await downloadFile(url, filename, outputDir, multiBar, episodeNum);
 }
 
-module.exports = {
-    searchAnime,
-    searchAll,
-    getEpisodes,
-    getDownloadLinks,
-    pickLink,
-    downloadEpisode,
-};
+module.exports = { searchAnime, searchAll, getEpisodes, getDownloadLinks, pickLink, downloadEpisode };

package/utils.js

@@ -4,10 +4,21 @@ const os = require('os');
 const chalk = require('chalk');
 
 // --- Configuration ---
-const API_DOMAIN = 'https://arcane-nx-cipher-pol.hf.space/api';
-const SEARCH_API = `${API_DOMAIN}/anime/search`;
-const INFO_API = `${API_DOMAIN}/anime/info`;
-const DOWNLOAD_API = `${API_DOMAIN}/anime/download`;
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'ani-auto');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+function loadConfig() {
+    try {
+        return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+    } catch {
+        return {};
+    }
+}
+
+const config = loadConfig();
+const API_DOMAIN = config.apiBaseUrl || 'https://aor-rex-anikuro-api.hf.space';
+const SEARCH_API = `${API_DOMAIN}/api/anime/search`;
+const RELEASES_API = `${API_DOMAIN}/api/anime`;
 const USER_AGENT = 'Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36';
 
 // --- Helpers ---
@@ -43,14 +54,35 @@ async function downloadFile(url, filename, folder, multiBar, episode) {
     }) : null;
 
     try {
-        const headers = {
+        // Strategy: try direct with Referer first; if 403, fall back to cookie extraction
+        let response = await _fetchWithCookie(url, {
             'User-Agent': USER_AGENT,
-            'Referer': 'https://kwik.cx/'
-        };
-
-        if (fileExists) headers['Range'] = `bytes=${downloadedBytes}-`;
-
-        const response = await fetch(url, { headers });
+            'Referer': 'https://kwik.cx/',
+            'Origin': 'https://kwik.cx',
+        }, fileExists ? downloadedBytes : null);
+
+        if (response.status === 403) {
+            // Cloudflare Turnstile — solve with Puppeteer, retry with cookie
+            if (progressBar) progressBar.update(0, { episode, speed: 'solving CF...', value_formatted: '0 B', total_formatted: 'Unknown' });
+            const { getCachedCookie, invalidateCache } = require('./src/cloudflare');
+            const cookie = await getCachedCookie(url);
+            response = await _fetchWithCookie(url, {
+                'User-Agent': USER_AGENT,
+                'Referer': 'https://kwik.cx/',
+                'Cookie': `cf_clearance=${cookie}`,
+            }, fileExists ? downloadedBytes : null);
+
+            // If still 403 after cookie, invalidate and retry once
+            if (response.status === 403) {
+                invalidateCache();
+                const newCookie = await getCachedCookie(url);
+                response = await _fetchWithCookie(url, {
+                    'User-Agent': USER_AGENT,
+                    'Referer': 'https://kwik.cx/',
+                    'Cookie': `cf_clearance=${newCookie}`,
+                }, fileExists ? downloadedBytes : null);
+            }
+        }
 
         if (response.status === 416) {
             if (progressBar) { progressBar.update(100, { episode, value_formatted: 'Complete', total_formatted: 'Complete', speed: '0 B/s' }); progressBar.stop(); }
@@ -106,10 +138,14 @@ async function downloadFile(url, filename, folder, multiBar, episode) {
     }
 }
 
+async function _fetchWithCookie(url, headers, resumeFrom) {
+    if (resumeFrom) headers['Range'] = `bytes=${resumeFrom}-`;
+    return fetch(url, { headers });
+}
+
 module.exports = {
     SEARCH_API,
-    INFO_API,
-    DOWNLOAD_API,
+    RELEASES_API,
     USER_AGENT,
     sleep,
     getTerminalWidth,