ani-auto 1.0.4 → 1.2.0

package/README.md

@@ -21,6 +21,25 @@ ani-auto check
 
 ---
 
+## features
+
+**1. anilist sync**
+stays in sync with your watching list — only downloads episodes you haven't seen yet.
+
+**2. quality control**
+choose your preferred quality on each run or set a default.
+
+**3. background daemon**
+set it and forget it — checks for new episodes automatically on a schedule.
+
+**4. pause & resume**
+disable any anime at any time without losing your download history.
+
+**5. telegram notifications**
+get notified on your phone when episodes download, fail, or the daemon starts. message @userinfobot on telegram to get your chat id, then run `ani-auto setup`.
+
+---
+
 ## commands
 
 ```
@@ -48,7 +67,7 @@ Commands:
 
 ---
 
-## config options
+## configuration
 
 ```bash
 ani-auto config --set-quality 1080p

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ani-auto",
-  "version": "1.0.4",
+  "version": "1.2.0",
   "description": "Automatic anime episode downloader",
   "bin": {
     "ani-auto": "./src/cli.js"

package/src/cli.js

@@ -89,6 +89,7 @@ program
             { type: 'number', name: 'concurrency',           message: 'Parallel downloads per run (1-10):', default: current.concurrency || 2, validate: v => (v >= 1 && v <= 10) ? true : 'Enter a number 1–10' },
             { type: 'input',  name: 'outputDir',             message: 'Output directory for downloads:', default: current.outputDir },
             { type: 'number', name: 'daemonIntervalMinutes', message: 'Daemon polling interval (minutes):', default: current.daemonIntervalMinutes || 30 },
+            { type: 'input',  name: 'telegramChatId',        message: 'Telegram chat ID for notifications (leave blank to skip):\n  → Message @userinfobot on Telegram to get your ID:', default: current.telegramChatId || '' },
         ]);
         answers.anilistUsername = anilistUsername;
         answers.anilistToken    = anilistToken;
@@ -101,14 +102,15 @@ program
         }
 
         updateConfig({
-            anilistUsername: answers.anilistUsername || null,
-            anilistToken:    answers.anilistToken    || null,
-            watchStatuses:   answers.watchStatuses   || current.watchStatuses,
-            quality:         answers.quality,
-            language:        answers.language,
-            concurrency:     answers.concurrency,
-            outputDir:       answers.outputDir,
+            anilistUsername:  answers.anilistUsername || null,
+            anilistToken:     answers.anilistToken    || null,
+            watchStatuses:    answers.watchStatuses   || current.watchStatuses,
+            quality:          answers.quality,
+            language:         answers.language,
+            concurrency:      answers.concurrency,
+            outputDir:        answers.outputDir,
             daemonIntervalMinutes: answers.daemonIntervalMinutes,
+            telegramChatId:   answers.telegramChatId  || null,
         });
 
         console.log(chalk.green(`\n  ✔  Config saved to ${CONFIG_FILE}\n`));
@@ -126,6 +128,7 @@ program
             const config = loadConfig();
             let quality  = config.quality  || '1080p';
             let language = config.language || 'sub';
+            let range    = null;
 
             if (!opts.auto) {
                 const { pickedQuality, saveAsDefault } = await inquirer.prompt([
@@ -148,9 +151,34 @@ program
                     updateConfig({ quality });
                     console.log(chalk.green(`  ✔  Saved default quality: ${quality}\n`));
                 }
+
+                const { useRange } = await inquirer.prompt([{
+                    type:    'confirm',
+                    name:    'useRange',
+                    message: 'Download a specific episode range?',
+                    default: false,
+                }]);
+                if (useRange) {
+                    const { rangeInput } = await inquirer.prompt([{
+                        type:    'input',
+                        name:    'rangeInput',
+                        message: 'Enter range (e.g. 1-24 or 5 for single episode):',
+                        validate: (v) => {
+                            const clean = v.trim();
+                            if (/^\d+$/.test(clean)) return true;
+                            if (/^\d+-\d+$/.test(clean)) {
+                                const [a, b] = clean.split('-').map(Number);
+                                if (a > b) return 'Start must be less than or equal to end';
+                                return true;
+                            }
+                            return 'Enter a number (e.g. 5) or range (e.g. 1-24)';
+                        }
+                    }]);
+                    range = rangeInput.trim();
+                }
             }
 
-            await runCycle({ auto: !!opts.auto, quality, language });
+            await runCycle({ auto: !!opts.auto, quality, language, range });
         }
         catch (e) { console.error(chalk.red('[ERROR]'), e.message); process.exit(1); }
     });

package/src/config.js

@@ -1,57 +1,37 @@
 'use strict';
 
-const fs = require('fs');
+const fs   = require('fs');
 const path = require('path');
-const os = require('os');
+const os   = require('os');
 
-const CONFIG_DIR = path.join(os.homedir(), '.config', 'ani-auto');
+const CONFIG_DIR  = path.join(os.homedir(), '.config', 'ani-auto');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 
 const DEFAULTS = {
-    // AniList
-    anilistToken: null,
-    anilistUsername: null,
-
-    // Which AniList statuses to auto-download
-    watchStatuses: ['CURRENT'],
-
-    // Manual overrides: array of { title, quality, language, enabled }
-    manualList: [],
-
-    // Download settings
-    quality: '1080p',
-    language: 'sub',
-    concurrency: 2,
-    outputDir: path.join(os.homedir(), 'anime'),
-    maxRetries: 3,
-
-    // Scheduling
-    daemonIntervalMinutes: 30,   // how often the daemon polls
-    cronSchedule: '0 */2 * * *', // every 2 hours (for cron mode)
-
-    // Behaviour
-    skipExisting: true,          // skip episodes already in DB
-    maxEpisodesPerRun: 50,       // safety cap per check cycle
+    anilistToken:          null,
+    anilistUsername:       null,
+    watchStatuses:         ['CURRENT'],
+    manualList:            [],
+    quality:               '1080p',
+    language:              'sub',
+    concurrency:           2,
+    outputDir:             path.join(os.homedir(), 'anime'),
+    maxRetries:            3,
+    daemonIntervalMinutes: 30,
+    cronSchedule:          '0 */2 * * *',
+    skipExisting:          true,
+    maxEpisodesPerRun:     50,
 };
 
 function ensureConfigDir() {
-    if (!fs.existsSync(CONFIG_DIR)) {
-        fs.mkdirSync(CONFIG_DIR, { recursive: true });
-    }
+    if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
 }
 
 function loadConfig() {
     ensureConfigDir();
-    if (!fs.existsSync(CONFIG_FILE)) {
-        saveConfig(DEFAULTS);
-        return { ...DEFAULTS };
-    }
-    try {
-        const raw = fs.readFileSync(CONFIG_FILE, 'utf8');
-        return { ...DEFAULTS, ...JSON.parse(raw) };
-    } catch {
-        return { ...DEFAULTS };
-    }
+    if (!fs.existsSync(CONFIG_FILE)) { saveConfig(DEFAULTS); return { ...DEFAULTS }; }
+    try { return { ...DEFAULTS, ...JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')) }; }
+    catch { return { ...DEFAULTS }; }
 }
 
 function saveConfig(config) {
@@ -60,20 +40,11 @@ function saveConfig(config) {
 }
 
 function updateConfig(partial) {
-    const current = loadConfig();
-    const updated = { ...current, ...partial };
+    const updated = { ...loadConfig(), ...partial };
     saveConfig(updated);
     return updated;
 }
 
 const getConfigPath = () => CONFIG_FILE;
 
-module.exports = {
-    CONFIG_FILE,
-    CONFIG_DIR,
-    DEFAULTS,
-    loadConfig,
-    saveConfig,
-    updateConfig,
-    getConfigPath,
-};
+module.exports = { CONFIG_FILE, CONFIG_DIR, DEFAULTS, loadConfig, saveConfig, updateConfig, getConfigPath };

package/src/daemon.js

@@ -12,6 +12,7 @@ const chalk = require('chalk');
 const { CronJob } = require('cron');
 const { loadConfig } = require('./config');
 const { runCycle }   = require('./engine');
+const notify         = require('./notify');
 
 let running = false;   // prevents overlapping runs
 
@@ -52,6 +53,9 @@ async function startDaemon() {
     console.log(chalk.cyan(`  Output:    ${config.outputDir}`));
     console.log(chalk.gray(`  Started:   ${ts()}\n`));
 
+    // Notify daemon started
+    await notify.notifyDaemonStart(config.daemonIntervalMinutes || 30);
+
     // Run immediately on start
     await safeRun();
 
@@ -65,8 +69,16 @@ async function startDaemon() {
     console.log(chalk.green(`  Daemon running. Press Ctrl+C to stop.\n`));
 
     // Graceful shutdown
-    process.on('SIGINT',  () => { console.log(chalk.yellow('\n  Shutting down daemon...')); process.exit(0); });
-    process.on('SIGTERM', () => { console.log(chalk.yellow('\n  Daemon terminated.')); process.exit(0); });
+    process.on('SIGINT',  async () => {
+        console.log(chalk.yellow('\n  Shutting down daemon...'));
+        await notify.notifyDaemonStop();
+        process.exit(0);
+    });
+    process.on('SIGTERM', async () => {
+        console.log(chalk.yellow('\n  Daemon terminated.'));
+        await notify.notifyDaemonStop();
+        process.exit(0);
+    });
 }
 
 startDaemon().catch(e => {

package/src/engine.js

@@ -10,6 +10,8 @@ const { loadConfig }             = require('./config');
 const db                         = require('./db');
 const { getUserList, pickTitle } = require('./anilist');
 const scraper                    = require('./scraper');
+const { version }                = require('../package.json');
+const notify                     = require('./notify');
 
 // ── Logging ────────────────────────────────────────────────────────────────
 
@@ -129,7 +131,7 @@ async function promptAnimeSelection(watchList) {
 
 // ── Per-anime download ─────────────────────────────────────────────────────
 
-async function processAnime(workItem, config, multiBar, auto = false, runQuality = null, runLanguage = null) {
+async function processAnime(workItem, config, multiBar, auto = false, runQuality = null, runLanguage = null, range = null) {
     const q = runQuality  || workItem.quality  || config.quality  || '1080p';
     const l = runLanguage || workItem.language || config.language || 'sub';
 
@@ -137,25 +139,27 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
     const existingRow = db.getAnimeBySiteTitle(workItem.title);
     let siteAnime;
 
-    if (existingRow?.confirmed_site_id) {
-        siteAnime = { session: existingRow.confirmed_site_id, title: existingRow.confirmed_site_title };
+    // Always do a fresh search — session IDs expire on AnimePahe
+    const siteResults = await scraper.searchAll(workItem.title);
+    if (!siteResults.length) {
+        warn(`[${workItem.title}] Not found on site — skipping.`);
+        return { downloaded: 0, skipped: 0, failed: 0 };
+    }
+
+    if (existingRow?.confirmed_site_title) {
+        // We have a saved title preference — find it in fresh results
+        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)}`);
+        // Update session ID in DB
+        db.saveConfirmedSiteMatch(workItem.title, siteAnime.session, siteAnime.title);
     } else if (auto) {
-        const siteResults = await scraper.searchAll(workItem.title);
-        if (!siteResults.length) {
-            warn(`[${workItem.title}] Not found on site — skipping.`);
-            return { downloaded: 0, skipped: 0, failed: 0 };
-        }
         siteAnime = siteResults[0];
         db.saveConfirmedSiteMatch(workItem.title, siteAnime.session, siteAnime.title);
         info(`[${workItem.title}] Auto-matched to: ${chalk.bold(siteAnime.title)}`);
     } else {
-        const siteResults = await scraper.searchAll(workItem.title);
-        if (!siteResults.length) {
-            warn(`[${workItem.title}] Not found on site — skipping.`);
-            return { downloaded: 0, skipped: 0, failed: 0 };
-        }
-
         const topResults = siteResults.slice(0, 5);
         const { pick } = await inquirer.prompt([{
             type:    'list',
@@ -212,7 +216,24 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
     const sortedEpisodes = [...episodes].sort((a, b) => a.episode - b.episode);
     const watched        = workItem.watchedEpisodes || 0;
     const unwatched      = sortedEpisodes.slice(watched);
-    const toDownload     = unwatched.filter(ep => !db.isEpisodeDownloaded(dbRow.id, ep.episode));
+    let toDownload = unwatched.filter(ep => !db.isEpisodeDownloaded(dbRow.id, ep.episode));
+
+    // Apply episode range filter if specified
+    if (range) {
+        const clean = range.trim();
+        let rangeFrom, rangeTo;
+        if (/^\d+$/.test(clean)) {
+            rangeFrom = rangeTo = parseInt(clean);
+        } else {
+            [rangeFrom, rangeTo] = clean.split('-').map(Number);
+        }
+        // Range is relative to the unwatched slice (1 = first unwatched episode)
+        toDownload = toDownload.filter((ep, idx) => {
+            const pos = idx + 1;
+            return pos >= rangeFrom && pos <= rangeTo;
+        });
+        info(`[${workItem.title}] Range filter: episodes ${rangeFrom}${rangeTo !== rangeFrom ? '–' + rangeTo : ''} (${toDownload.length} matched).`);
+    }
 
     if (!toDownload.length) {
         info(`[${workItem.title}] Nothing new (watched ${watched}/${sortedEpisodes.length} episodes).`);
@@ -221,12 +242,13 @@ 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}).`);
 
-    // Use AniList title for folder — consistent with what user sees on AniList
-    const cleanTitle  = buildFolderName(workItem.title);
-    const season      = detectSeason(workItem.title);
-    // Strip "Season X" from the display title used in filename to avoid duplication
-    const displayTitle = cleanTitle.replace(/\s*season\s*\d+\s*/gi, '').trim();
-    const outputDir   = path.join(config.outputDir, cleanTitle);
+    // Folder uses AniList title — consistent with what user sees on AniList
+    const cleanTitle   = buildFolderName(workItem.title);
+    const season       = detectSeason(workItem.title);
+    // Filename uses site title (better casing) with Season X stripped to avoid duplication
+    const siteClean    = buildFolderName(siteAnime.title || workItem.title);
+    const displayTitle = siteClean.replace(/[:\s]*season\s*\d+[:\s]*/gi, ' ').replace(/\s+/g, ' ').trim();
+    const outputDir    = path.join(config.outputDir, cleanTitle);
     if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });
 
     const queue       = [...toDownload];
@@ -259,12 +281,14 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
 
                     db.markEpisodeStatus(dbRow.id, ep.episode, 'done', filename);
                     ok(`[${cleanTitle}] EP${ep.episode} → ${filename}`);
+                    await notify.notifyEpisode(cleanTitle, relativeEp || ep.episode);
                     success = true;
                     results.downloaded++;
                 } catch (e) {
                     if (attempts >= MAX_RETRIES) {
                         err(`[${workItem.title}] EP${ep.episode} failed: ${e.message}`);
                         db.markEpisodeStatus(dbRow.id, ep.episode, 'failed', null, e.message);
+                        await notify.notifyFailed(workItem.title, ep.episode, e.message);
                         results.failed++;
                     } else {
                         warn(`[${workItem.title}] EP${ep.episode} attempt ${attempts} failed, retrying...`);
@@ -281,12 +305,12 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
 
 // ── Main cycle ─────────────────────────────────────────────────────────────
 
-async function runCycle({ auto = false, quality = null, language = null } = {}) {
+async function runCycle({ auto = false, quality = null, language = null, range = null } = {}) {
     await db.initDb();
     const config = loadConfig();
 
     console.log(chalk.bold.red('\n  ╔══════════════════════════════╗'));
-    console.log(chalk.bold.red('  ║      ANI-AUTO — CHECK RUN    ║'));
+    console.log(chalk.bold.red(`  ║   ANI-AUTO v${version} — CHECK RUN  ║`));
     console.log(chalk.bold.red('  ╚══════════════════════════════╝\n'));
 
     const watchList = await resolveWatchList(config);
@@ -323,7 +347,7 @@ async function runCycle({ auto = false, quality = null, language = null } = {})
     const totals = { downloaded: 0, skipped: 0, failed: 0 };
 
     for (const item of selected) {
-        const result = await processAnime(item, config, multiBar, auto, quality, language);
+        const result = await processAnime(item, config, multiBar, auto, quality, language, range);
         totals.downloaded += result.downloaded;
         totals.skipped    += result.skipped;
         totals.failed     += result.failed;
@@ -338,6 +362,7 @@ async function runCycle({ auto = false, quality = null, language = null } = {})
     console.log(chalk.bold('  ─────────────────────────────────────\n'));
 
     db.logRun(totals);
+    await notify.notifySummary(totals);
 }
 
 function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }

package/src/notify.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const { execSync } = require('child_process');
+const { loadConfig } = require('./config');
+
+// Bot token is shared — each user only needs their own chat ID
+// Users get their chat ID by messaging @anime_auto_downloader_bot on Telegram
+const BOT_TOKEN = '8695132702:AAEFDoSL6nkdwDOoz5wmoVkmuhaYa4tNw0o';
+
+// ── Telegram ───────────────────────────────────────────────────────────────
+
+async function sendTelegram(text) {
+    const config = loadConfig();
+    const chatId = config.telegramChatId;
+    if (!chatId) return;
+    try {
+        const fetch = require('node-fetch');
+        await fetch(`https://api.telegram.org/bot${BOT_TOKEN}/sendMessage`, {
+            method:  'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body:    JSON.stringify({
+                chat_id:    String(chatId),
+                text,
+                parse_mode: 'HTML',
+            }),
+        });
+    } catch (e) {
+        // silently fail — never crash the download for a notification
+    }
+}
+
+// ── KDE Desktop (notify-send) ──────────────────────────────────────────────
+
+function sendDesktop(title, body, urgency = 'normal') {
+    try {
+        // KDE uses notify-send from libnotify
+        execSync(`notify-send -u ${urgency} -a "ani-auto" "${title}" "${body}"`, { stdio: 'ignore' });
+    } catch (e) {
+        // silently fail if notify-send not available
+    }
+}
+
+// ── Public notification functions ─────────────────────────────────────────
+
+async function notifyEpisode(animeTitle, episode) {
+    const msg   = `✅ <b>${animeTitle}</b>\nEpisode ${episode} downloaded`;
+    const short = `Episode ${episode} downloaded`;
+    await sendTelegram(msg);
+    sendDesktop(animeTitle, short);
+}
+
+async function notifyFailed(animeTitle, episode, error) {
+    const msg   = `❌ <b>${animeTitle}</b>\nEpisode ${episode} failed: ${error}`;
+    const short = `Episode ${episode} failed`;
+    await sendTelegram(msg);
+    sendDesktop(animeTitle, short, 'critical');
+}
+
+async function notifySummary(totals) {
+    if (totals.downloaded === 0 && totals.failed === 0) return; // skip empty runs
+    const msg = 
+        `📋 <b>ani-auto — run complete</b>\n` +
+        `✅ Downloaded: ${totals.downloaded}\n` +
+        `⏭  Skipped:    ${totals.skipped}\n` +
+        `❌ Failed:     ${totals.failed}`;
+    const short = `↓${totals.downloaded}  ✗${totals.failed}`;
+    await sendTelegram(msg);
+    sendDesktop('ani-auto run complete', short);
+}
+
+async function notifyDaemonStart(intervalMinutes) {
+    const msg   = `🚀 <b>ani-auto daemon started</b>\nChecking every ${intervalMinutes} minutes`;
+    const short = `Checking every ${intervalMinutes} minutes`;
+    await sendTelegram(msg);
+    sendDesktop('ani-auto daemon started', short);
+}
+
+async function notifyDaemonStop() {
+    const msg = `🛑 <b>ani-auto daemon stopped</b>`;
+    await sendTelegram(msg);
+    sendDesktop('ani-auto daemon stopped', '');
+}
+
+module.exports = {
+    notifyEpisode,
+    notifyFailed,
+    notifySummary,
+    notifyDaemonStart,
+    notifyDaemonStop,
+};