ani-auto 1.3.3 → 1.4.2

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "ani-auto",
-  "version": "1.3.3",
-  "description": "Automatic anime episode downloader",
+  "version": "1.4.2",
+  "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/cli.js

@@ -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,6 +748,11 @@ 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`));
@@ -768,8 +778,8 @@ program
                 updateConfig({ daemonEnabled: true });
                 console.log(chalk.green('\n  Done  Daemon enabled.'));
                 console.log(chalk.gray('  Starting systemd service...\n'));
-                const r = run(`systemctl --user start ${SERVICE}`);
-                if (r.code === 0) {
+                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?).'));

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,17 +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,         
+    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}`); }
 
@@ -89,17 +88,11 @@ async function startDaemon() {
 
     // ── Enabled gate ──────────────────────────────────────────────────────
     if (config.daemonEnabled === false) {
-        console.log(chalk.yellow(`
-  ┌─────────────────────────────────────────────────┐
-  │          ani-auto daemon is DISABLED             │
-  │                                                  │
-  │  The daemon will not run until you enable it.    │
-  │  To re-enable, run:                              │
-  │                                                  │
-  │    ani-auto daemon enable                        │
-  └─────────────────────────────────────────────────┘
-`));
-        process.exit(0);
+        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;
@@ -143,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/engine.js

@@ -13,6 +13,7 @@ const scraper                    = require('./scraper');
 const { version }                = require('../package.json');
 const notify                     = require('./notify');
 
+// ── Logging ────────────────────────────────────────────────────────────────
 
 function info(msg) { console.log(`${chalk.gray(ts())} ${chalk.cyan('ℹ')}  ${msg}`); }
 function ok(msg)   { console.log(`${chalk.gray(ts())} ${chalk.green('✔')}  ${msg}`); }
@@ -20,6 +21,7 @@ function warn(msg) { console.log(`${chalk.gray(ts())} ${chalk.yellow('⚠')}  ${
 function err(msg)  { console.log(`${chalk.gray(ts())} ${chalk.red('✖')}  ${msg}`); }
 function ts()      { return new Date().toISOString().replace('T', ' ').slice(0, 19); }
 
+// ── Filename helpers ───────────────────────────────────────────────────────
 
 function buildFilename(title, episodeNum, season = null, displayEpisodeNum = null) {
     const s  = season ? `Season ${season} ` : '';
@@ -43,6 +45,7 @@ function detectSeason(title) {
     return m ? parseInt(m[1], 10) : null;
 }
 
+// ── Watch list ─────────────────────────────────────────────────────────────
 
 async function resolveWatchList(config) {
     const items = [];
@@ -100,6 +103,7 @@ async function resolveWatchList(config) {
     });
 }
 
+// ── Anime selector prompt ──────────────────────────────────────────────────
 
 async function promptAnimeSelection(watchList) {
     console.log(chalk.bold('\n  Available anime:'));
@@ -108,28 +112,63 @@ async function promptAnimeSelection(watchList) {
         const status  = item.anilistStatus   ? chalk.gray(` [${item.anilistStatus}]`) : '';
         console.log(`  ${chalk.cyan(i + 1)}. ${item.title}${watched}${status}`);
     });
-    console.log(`  ${chalk.cyan('a')}. All`);
+    console.log(`  ${chalk.cyan('s')}. Search and select`);
     console.log('');
 
     const { input } = await inquirer.prompt([{
         type:    'input',
         name:    'input',
-        message: 'Enter numbers to download (e.g. 1,3 or "a" for all):',
-        default: 'a',
-        validate: (val) => {
-            if (val.trim().toLowerCase() === 'a') return true;
-            const nums = val.split(',').map(s => parseInt(s.trim()));
-            if (nums.some(isNaN)) return 'Enter comma-separated numbers or "a"';
-            if (nums.some(n => n < 1 || n > watchList.length)) return `Numbers must be between 1 and ${watchList.length}`;
-            return true;
-        }
+        message: 'Enter numbers to download, "s" to search, or Enter for all:',
+        default: '',
     }]);
 
-    if (input.trim().toLowerCase() === 'a') return watchList;
-    const indices = input.split(',').map(s => parseInt(s.trim()) - 1);
-    return indices.map(i => watchList[i]);
+    const choice = input.trim().toLowerCase();
+
+    if (choice === 's') {
+        const { query } = await inquirer.prompt([{
+            type:    'input',
+            name:    'query',
+            message: 'Search anime:',
+            default: '',
+        }]);
+
+        const searchTerm = query.trim().toLowerCase();
+        const filtered = searchTerm
+            ? watchList.filter(item => item.title.toLowerCase().includes(searchTerm))
+            : watchList;
+
+        if (!filtered.length) {
+            console.log(chalk.yellow('  No matching anime found.\n'));
+            return [];
+        }
+
+        console.log(chalk.bold(`\n  Found ${filtered.length} match(es):`));
+
+        const { picked } = await inquirer.prompt([{
+            type:    'checkbox',
+            name:    'picked',
+            message: 'Select anime to download:',
+            choices: filtered.map(item => {
+                const watched = item.watchedEpisodes ? ` (watched: ${item.watchedEpisodes})` : '';
+                const status = item.anilistStatus ? ` [${item.anilistStatus}]` : '';
+                return {
+                    name:  `${item.title}${watched}${status}`,
+                    value: item,
+                    checked: true,
+                };
+            }),
+            pageSize: 15,
+        }]);
+
+        return picked.length ? picked : [];
+    }
+
+    if (!choice || choice === 'a') return watchList;
+    const indices = choice.split(',').map(s => parseInt(s.trim()) - 1);
+    return indices.map(i => watchList[i]).filter(Boolean);
 }
 
+// ── Per-anime download ─────────────────────────────────────────────────────
 
 async function processAnime(workItem, config, multiBar, auto = false, runQuality = null, runLanguage = null, range = null) {
     // Per-anime quality: run override > DB override > workItem > global config
@@ -146,24 +185,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',
@@ -171,7 +227,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 },
@@ -270,6 +326,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);
@@ -295,7 +354,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');
 
@@ -328,6 +387,7 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
     return results;
 }
 
+// ── Main cycle ─────────────────────────────────────────────────────────────
 
 async function runCycle({ auto = false, quality = null, language = null, range = null, statuses = null } = {}) {
     await db.initDb();
@@ -394,4 +454,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/notify.js

@@ -39,16 +39,35 @@ async function sendDesktop(title, body, urgency = 'normal', posterUrl = null) {
     } catch (e) {}
 }
 
+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'}`;
+        `✅  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);
+    const p2 = sendDesktop(animeTitle, `episode ${episode} downloaded`, 'normal', posterUrl);
     await Promise.allSettled([p1, p2]);
 }
 
@@ -56,11 +75,11 @@ 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 Promise.allSettled([
         sendTelegram({ text }),
-        sendDesktop(animeTitle, `Episode ${episode} failed`, 'critical')
+        sendDesktop(animeTitle, `episode ${episode} failed`, 'critical')
     ]);
 }
 
@@ -69,12 +88,12 @@ 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}`;
+        `✅  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}`)
+        sendDesktop('ani-auto run complete', `downloaded: ${totals.downloaded}  failed: ${totals.failed}`)
     ]);
 }
 
@@ -83,12 +102,12 @@ 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`;
+        `📦  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`)
+        sendDesktop(`ani-auto v${version} started`, `downloading ${downloadingCount} anime · every ${intervalMinutes} min`)
     ]);
 }
 
@@ -99,4 +118,4 @@ async function notifyDaemonStop() {
     ]);
 }
 
-module.exports = { notifyEpisode, notifyFailed, notifySummary, notifyDaemonStart, notifyDaemonStop };
+module.exports = { notifyDownloadStart, notifyEpisode, notifyFailed, notifySummary, notifyDaemonStart, notifyDaemonStop };

package/src/scraper.js

@@ -3,18 +3,7 @@
 const path  = require('path');
 const fetch = require('node-fetch');
 
-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 utils at "${UTILS_PATH}". Set KANIME_UTILS_PATH env var.\n${e.message}`);
-    }
-    return _utils;
-}
+const { SEARCH_API, RELEASES_API, USER_AGENT, downloadFile } = require('../utils');
 
 async function searchAnime(title) {
     const results = await searchAll(title);
@@ -25,13 +14,39 @@ async function searchAnime(title) {
 }
 
 async function searchAll(title) {
-    const { SEARCH_API, USER_AGENT } = utils();
     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(`API returned ${res.status}`);
+        if (!res.ok) throw new Error(`Search API returned ${res.status}`);
         const data = await res.json();
-        return data.results || [];
+        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);
@@ -39,36 +54,73 @@ async function searchAll(title) {
 }
 
 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);
 }
 
-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,
+    }));
 }
 
 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]
     );
 }
 
 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,

package/CHANGELOG.md

@@ -1,82 +0,0 @@
-# Changelog
-
-## [1.3.3]
-### added
-- daemon can be fully enabled or disabled — blocks all startup on boot and network restore when disabled
-
----
-
-## [1.3.1]
-### fixed
-- stability patch
-
-### added
-- poster images included in telegram and desktop notifications
-- daemon and notification toggle
-
----
-
-## [1.3.0]
-### added
-- toggle to enable/disable the daemon without uninstalling it
-
----
-
-## [1.2.4]
-### fixed
-- removed node.js warnings on startup
-
----
-
-## [1.2.3]
-### added
-- check for updates and install latest version in one step
-
----
-
-## [1.2.2]
-### added
-- anilist watch list status selection on each download run (current, planning, paused, repeating)
-
----
-
-## [1.2.1]
-### fixed
-- banner design fix
-
----
-
-## [1.2.0]
-### added
-- desktop notifications (kde/linux)
-- telegram notifications — episode downloaded, failed, run summary, daemon start/stop
-- poster images in notifications
-
----
-
-## [1.1.0]
-### added
-- quality prompt on each download run
-- pause downloads per anime while keeping history
-- skips anime that already exist in your anilist list when adding manually
-
-### fixed
-- session handling fix
-
----
-
-## [1.0.4]
-### fixed
-- error name fix
-
----
-
-## [1.0.2]
-### fixed
-- daemon bug fix
-- major bug fix
-
----
-
-## [1.0.0]
-- initial release