ani-auto 1.2.5 → 1.3.1

package/src/config.js

@@ -13,14 +13,16 @@ const DEFAULTS = {
     watchStatuses:         ['CURRENT'],
     manualList:            [],
     quality:               '1080p',
-    language:              'sub',
+    language:              'sub',        
     concurrency:           2,
     outputDir:             path.join(os.homedir(), 'anime'),
     maxRetries:            3,
-    daemonIntervalMinutes: 30,
-    cronSchedule:          '0 */2 * * *',
+    daemonIntervalMinutes: 120,
     skipExisting:          true,
     maxEpisodesPerRun:     50,
+    telegramChatId:        null,         
+    telegramNotify:        true,         
+    airingBufferMinutes:   5,            // minutes after air time before checking AnimePahe
 };
 
 function ensureConfigDir() {

package/src/daemon.js

@@ -1,27 +1,36 @@
 #!/usr/bin/env node
 'use strict';
 process.removeAllListeners('warning');
-/**
- * daemon.js
- * Keeps running indefinitely, polling on a configurable interval.
- * Also registers a cron schedule as a secondary trigger.
- *
- * Usage:  node src/daemon.js
- *         npm start
- */
-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
+
+const chalk  = require('chalk');
+const { loadConfig }          = require('./config');
+const { runCycle }            = require('./engine');
+const { waitForInternet, checkInternet } = require('./network');
+const notify = require('./notify');
+const db     = require('./db');
+
+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}`); }
 
 async function safeRun() {
     if (running) {
-        console.log(chalk.yellow(`[${ts()}] Previous run still in progress — skipping.`));
+        warn('Previous run still in progress — skipping.');
         return;
     }
+
+    // Check internet before running
+    const online = await checkInternet();
+    if (!online) {
+        warn('No internet connection — waiting for network...');
+        await waitForInternet();
+        info('Internet restored — starting cycle.');
+    }
+
     running = true;
     try {
         await runCycle({ auto: true });
@@ -32,12 +41,52 @@ async function safeRun() {
     }
 }
 
-function ts() { return new Date().toISOString().replace('T',' ').slice(0,19); }
+// ── Smart scheduling ───────────────────────────────────────────────────────
 
-async function startDaemon() {
+const smartTimers = new Map();
+
+async function scheduleSmartChecks() {
+    await db.initDb();
     const config = loadConfig();
-    const intervalMs = (config.daemonIntervalMinutes || 30) * 60 * 1000;
-    const cronSchedule = config.cronSchedule || '0 */2 * * *';
+    const now    = Math.floor(Date.now() / 1000);
+
+    // Clear existing smart timers
+    for (const [, timer] of smartTimers) clearTimeout(timer);
+    smartTimers.clear();
+
+    // Get all anime with a next airing time
+    const allAnime = db.getAllEnabledAnime ? db.getAllEnabledAnime() : [];
+    const BUFFER   = (config.airingBufferMinutes || 5) * 60;
+
+    for (const anime of allAnime) {
+        if (!anime.next_airing_at) continue;
+        const targetTime = anime.next_airing_at + BUFFER;
+        const delay      = (targetTime - now) * 1000;
+
+        if (delay <= 0) {
+            // Already past air time — check immediately on next safeRun
+            continue;
+        }
+
+        const title = anime.anilist_title || anime.title;
+        info(`Smart schedule: ${chalk.bold(title)} in ${Math.round(delay / 60000)} minutes`);
+
+        const timer = setTimeout(async () => {
+            info(`Smart trigger: checking ${chalk.bold(title)} (episode aired)`);
+            await safeRun();
+            // Reschedule after run to pick up next episode's air time
+            setTimeout(scheduleSmartChecks, 60000);
+        }, delay);
+
+        smartTimers.set(anime.id, timer);
+    }
+}
+
+// ── Startup ────────────────────────────────────────────────────────────────
+
+async function startDaemon() {
+    const config       = loadConfig();
+    const intervalMs   = (config.daemonIntervalMinutes || 30) * 60 * 1000;
 
     console.log(chalk.bold.red(`
    █████╗ ███╗   ██╗██╗      █████╗ ██╗   ██╗████████╗ ██████╗ 
@@ -50,27 +99,38 @@ async function startDaemon() {
     `));
 
     console.log(chalk.cyan(`  Interval:  every ${config.daemonIntervalMinutes || 30} minutes`));
-    console.log(chalk.cyan(`  Cron:      ${cronSchedule}`));
     console.log(chalk.cyan(`  Output:    ${config.outputDir}`));
     console.log(chalk.gray(`  Started:   ${ts()}\n`));
 
-    // Notify daemon started
-    await notify.notifyDaemonStart(config.daemonIntervalMinutes || 30);
+    // Startup internet check
+    const online = await checkInternet();
+    if (!online) {
+        warn('No internet at startup — waiting for connection...');
+        await waitForInternet();
+        info('Internet available — starting.');
+    }
+
+    // Get tracking count for notification
+    await db.initDb();
+    const allTracked = db.getAllEnabledAnime ? db.getAllEnabledAnime() : [];
+    await notify.notifyDaemonStart(config.daemonIntervalMinutes || 120, allTracked.length);
 
     // Run immediately on start
     await safeRun();
 
-    // Interval-based polling
-    setInterval(safeRun, intervalMs);
+    // Set up smart scheduling after first run (DB now has airing data)
+    await scheduleSmartChecks();
+
+    // Interval-based fallback polling
+    setInterval(async () => {
+        await safeRun();
+        await scheduleSmartChecks(); // Refresh smart timers each interval
+    }, intervalMs);
 
-    // Cron-based trigger (secondary — e.g. aligned to midnight/air times)
-    const job = new CronJob(cronSchedule, safeRun, null, true, 'UTC');
-    job.start();
 
     console.log(chalk.green(`  Daemon running. Press Ctrl+C to stop.\n`));
 
-    // Graceful shutdown
-    process.on('SIGINT',  async () => {
+    process.on('SIGINT', async () => {
         console.log(chalk.yellow('\n  Shutting down daemon...'));
         await notify.notifyDaemonStop();
         process.exit(0);

package/src/db.js

@@ -56,6 +56,10 @@ function migrate(db) {
             language             TEXT,
             confirmed_site_id    TEXT,
             confirmed_site_title TEXT,
+            anilist_title        TEXT,
+            poster_url           TEXT,
+            override_quality     TEXT,
+            next_airing_at       INTEGER,
             added_at             TEXT    NOT NULL DEFAULT (datetime('now'))
         )
     `);
@@ -74,6 +78,10 @@ function migrate(db) {
     // 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_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) {}
+    try { db.run('ALTER TABLE anime ADD COLUMN override_quality TEXT'); } catch(e) {}
+    try { db.run('ALTER TABLE anime ADD COLUMN next_airing_at INTEGER'); } catch(e) {}
 
     db.run(`
         CREATE TABLE IF NOT EXISTS run_log (
@@ -168,6 +176,13 @@ function isEpisodeDownloaded(animeDbId, episodeNum) {
     );
 }
 
+function getEpisodeRow(animeDbId, episodeNum) {
+    return _get(
+        'SELECT * FROM episodes WHERE anime_id = ? AND episode_num = ?',
+        [animeDbId, episodeNum]
+    );
+}
+
 function markEpisodeStatus(animeDbId, episodeNum, status, filename = null, error = null) {
     _run(`
         INSERT INTO episodes (anime_id, episode_num, status, filename, downloaded_at, error)
@@ -209,31 +224,62 @@ function getDbInstance() {
 }
 
 function getAnimeBySiteTitle(title) {
-    return _get('SELECT * FROM anime WHERE LOWER(title) = LOWER(?)', [title]);
+    // Check by anilist_title first, then fall back to title column
+    return _get('SELECT * FROM anime WHERE LOWER(anilist_title) = LOWER(?)', [title])
+        || _get('SELECT * FROM anime WHERE LOWER(title) = LOWER(?)', [title]);
 }
 
-function saveConfirmedSiteMatch(title, confirmedSiteId, confirmedSiteTitle) {
-    // Try to update existing row first
-    const existing = _get('SELECT id FROM anime WHERE LOWER(title) = LOWER(?)', [title]);
+function saveConfirmedSiteMatch(anilistTitle, confirmedSiteId, confirmedSiteTitle, posterUrl = null) {
+    // Look up by anilist_title, AniList title matching title col, or site title matching title col
+    const existing =
+        _get('SELECT id FROM anime WHERE LOWER(anilist_title) = LOWER(?)', [anilistTitle]) ||
+        _get('SELECT id FROM anime WHERE LOWER(title) = LOWER(?)', [anilistTitle]) ||
+        _get('SELECT id FROM anime WHERE LOWER(title) = LOWER(?)', [confirmedSiteTitle]);
+
     if (existing) {
         _run(
-            'UPDATE anime SET confirmed_site_id = ?, confirmed_site_title = ? WHERE id = ?',
-            [confirmedSiteId, confirmedSiteTitle, existing.id]
+            'UPDATE anime SET confirmed_site_id = ?, confirmed_site_title = ?, anilist_title = ?, poster_url = COALESCE(?, poster_url) WHERE id = ?',
+            [confirmedSiteId, confirmedSiteTitle, anilistTitle, posterUrl, existing.id]
         );
     } else {
-        // No row yet — insert one using confirmedSiteId as the site_id
         _run(
-            'INSERT OR IGNORE INTO anime (title, site_id, confirmed_site_id, confirmed_site_title, source) VALUES (?, ?, ?, ?, ?)',
-            [title, confirmedSiteId, confirmedSiteId, confirmedSiteTitle, 'anilist']
+            'INSERT OR IGNORE INTO anime (title, anilist_title, site_id, confirmed_site_id, confirmed_site_title, poster_url, source) VALUES (?, ?, ?, ?, ?, ?, ?)',
+            [anilistTitle, anilistTitle, confirmedSiteId, confirmedSiteId, confirmedSiteTitle, posterUrl, 'anilist']
         );
     }
     _save();
 }
 
+function setAnimeQuality(title, quality) {
+    const row = _get('SELECT id FROM anime WHERE LOWER(anilist_title) = LOWER(?) OR LOWER(title) = LOWER(?)', [title, title]);
+    if (!row) return false;
+    _run('UPDATE anime SET override_quality = ? WHERE id = ?', [quality || null, row.id]);
+    return true;
+}
+
+function getFailedEpisodes() {
+    return _all(`
+        SELECT e.*, a.title, a.anilist_title, a.site_id, a.confirmed_site_id, a.confirmed_site_title,
+               a.override_quality, a.quality, a.language, a.source, a.poster_url
+        FROM episodes e
+        JOIN anime a ON e.anime_id = a.id
+        WHERE e.status = 'failed'
+        ORDER BY a.title, e.episode_num
+    `);
+}
+
+function getAllEpisodes(animeDbId) {
+    return _all('SELECT * FROM episodes WHERE anime_id = ? ORDER BY episode_num', [animeDbId]);
+}
+
+function updateNextAiring(animeDbId, airingAt) {
+    _run('UPDATE anime SET next_airing_at = ? WHERE id = ?', [airingAt, animeDbId]);
+}
+
 module.exports = {
     initDb,
     getDb: getDbInstance,
-    upsertAnime, getAnime, getAnimeBySiteTitle, saveConfirmedSiteMatch, getAllEnabledAnime, setAnimeEnabled, removeAnime,
-    isEpisodeDownloaded, markEpisodeStatus, getEpisodeStats,
+    upsertAnime, getAnime, getAnimeBySiteTitle, saveConfirmedSiteMatch, getAllEnabledAnime, setAnimeEnabled, setAnimeQuality, removeAnime,
+    isEpisodeDownloaded, getEpisodeRow, markEpisodeStatus, getEpisodeStats, getFailedEpisodes, getAllEpisodes, updateNextAiring,
     logRun, getRecentRuns,
 };

package/src/engine.js

@@ -69,6 +69,7 @@ async function resolveWatchList(config) {
                     knownEpisodes:   entry.totalEpisodes,
                     animeStatus:     entry.animeStatus,
                     anilistStatus:   entry.status,
+                    nextAiringAt:    entry.nextAiring?.airingAt || null,
                 });
             }
             info(`AniList returned ${chalk.bold(entries.length)} entries.`);
@@ -89,6 +90,7 @@ async function resolveWatchList(config) {
             knownEpisodes:   null,
             animeStatus:     null,
             anilistStatus:   null,
+            nextAiringAt:    null,
         });
     }
 
@@ -135,7 +137,9 @@ async function promptAnimeSelection(watchList) {
 // ── Per-anime download ─────────────────────────────────────────────────────
 
 async function processAnime(workItem, config, multiBar, auto = false, runQuality = null, runLanguage = null, range = null) {
-    const q = runQuality  || workItem.quality  || config.quality  || '1080p';
+    // Per-anime quality: run override > DB override > workItem > global config
+    const dbAnimeRow = db.getAnimeBySiteTitle(workItem.title);
+    const q = runQuality || dbAnimeRow?.override_quality || workItem.quality || config.quality || '1080p';
     const l = runLanguage || workItem.language || config.language || 'sub';
 
     const existingRow = db.getAnimeBySiteTitle(workItem.title);
@@ -153,10 +157,16 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
         ) || siteResults[0];
         siteAnime = savedMatch;
         info(`[${workItem.title}] Using saved site match: ${chalk.bold(siteAnime.title)}`);
-        db.saveConfirmedSiteMatch(workItem.title, siteAnime.session, siteAnime.title);
+        db.saveConfirmedSiteMatch(workItem.title, siteAnime.session, siteAnime.title, siteAnime.poster || null);
     } else if (auto) {
-        siteAnime = siteResults[0];
-        db.saveConfirmedSiteMatch(workItem.title, siteAnime.session, siteAnime.title);
+        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 {
         const topResults = siteResults.slice(0, 5);
@@ -179,7 +189,7 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
         }
 
         siteAnime = pick;
-        db.saveConfirmedSiteMatch(workItem.title, siteAnime.session, siteAnime.title);
+        db.saveConfirmedSiteMatch(workItem.title, siteAnime.session, siteAnime.title, siteAnime.poster || null);
         ok(`[${workItem.title}] Site match saved: ${chalk.bold(siteAnime.title)}`);
     }
 
@@ -192,6 +202,11 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
         language:  workItem.language || null,
     });
 
+    // Save next airing time for smart scheduling
+    if (workItem.nextAiringAt && dbRow?.id) {
+        db.updateNextAiring(dbRow.id, workItem.nextAiringAt);
+    }
+
     const enabledCheck = db.getAnimeBySiteTitle(workItem.title);
     if (dbRow.enabled === 0 || enabledCheck?.enabled === 0) {
         info(`[${workItem.title}] Disabled — skipping.`);
@@ -214,7 +229,29 @@ 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);
-    let toDownload = unwatched.filter(ep => !db.isEpisodeDownloaded(dbRow.id, ep.episode));
+
+    // Build folder name early so file existence check can use it
+    const cleanTitle   = buildFolderName(workItem.title);
+    const season       = detectSeason(workItem.title);
+    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 });
+
+    let toDownload = unwatched.filter(ep => {
+        if (!db.isEpisodeDownloaded(dbRow.id, ep.episode)) return true;
+        // Double-check the file actually exists on disk — re-download if missing
+        const epRow = db.getEpisodeRow(dbRow.id, ep.episode);
+        if (epRow?.filename) {
+            const filePath = path.join(outputDir, epRow.filename);
+            if (!fs.existsSync(filePath)) {
+                warn(`[${workItem.title}] EP${ep.episode} marked done but file missing — queuing re-download.`);
+                db.markEpisodeStatus(dbRow.id, ep.episode, 'pending');
+                return true;
+            }
+        }
+        return false;
+    });
 
     if (range) {
         const clean = range.trim();
@@ -228,7 +265,7 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
             const pos = idx + 1;
             return pos >= rangeFrom && pos <= rangeTo;
         });
-        info(`[${workItem.title}] Range filter: episodes ${rangeFrom}${rangeTo !== rangeFrom ? '–' + rangeTo : ''} (${toDownload.length} matched).`);
+        info(`[${workItem.title}] Range filter: episodes ${rangeFrom}${rangeTo !== rangeFrom ? '-' + rangeTo : ''} (${toDownload.length} matched).`);
     }
 
     if (!toDownload.length) {
@@ -238,13 +275,6 @@ 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 cleanTitle   = buildFolderName(workItem.title);
-    const season       = detectSeason(workItem.title);
-    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];
     const results     = { downloaded: 0, skipped: 0, failed: 0 };
     const concurrency = Math.min(config.concurrency || 2, queue.length);
@@ -252,7 +282,7 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
 
     // Pre-compute relative episode numbers before queueing
     const epRelativeMap = new Map();
-    toDownload.forEach((ep, idx) => {
+    toDownload.forEach((ep) => {
         const relEp = season
             ? sortedEpisodes.findIndex(e => e.episode === ep.episode) + 1
             : ep.episode;
@@ -275,12 +305,13 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
                     if (!link?.mp4Url) throw new Error('No suitable download link found');
 
                     const relativeEp = epRelativeMap.get(ep.episode) || ep.episode;
-                    const filename = buildFilename(displayTitle, ep.episode, season, relativeEp);
+                    const filename   = buildFilename(displayTitle, ep.episode, season, relativeEp);
                     await scraper.downloadEpisode(link.mp4Url, filename, outputDir, multiBar, ep.episode);
 
                     db.markEpisodeStatus(dbRow.id, ep.episode, 'done', filename);
                     ok(`[${cleanTitle}] EP${ep.episode} → ${filename}`);
-                    await notify.notifyEpisode(cleanTitle, relativeEp || ep.episode);
+                    const posterUrl = db.getAnimeBySiteTitle(workItem.title)?.poster_url || null;
+                    await notify.notifyEpisode(cleanTitle, relativeEp || ep.episode, q, posterUrl);
                     success = true;
                     results.downloaded++;
                 } catch (e) {
@@ -308,11 +339,10 @@ async function runCycle({ auto = false, quality = null, language = null, range =
     await db.initDb();
     const config = loadConfig();
 
-    console.log(chalk.bold.red('\n  ╔════════════════════════════════╗'));
-    console.log(chalk.bold.red(`  ║   ANI-AUTO v${version} — CHECK RUN  ║`));
-    console.log(chalk.bold.red('  ╚════════════════════════════════╝\n'));
+    console.log(chalk.bold.red('\n  ╔══════════════════════════════════╗'));
+    console.log(chalk.bold.red(`  ║  ANI-AUTO v${version} — DOWNLOAD RUN  ║`));
+    console.log(chalk.bold.red('  ╚══════════════════════════════════╝\n'));
 
-    // Use run-level statuses if provided, otherwise fall back to config
     const effectiveConfig = statuses
         ? { ...config, watchStatuses: statuses }
         : config;

package/src/network.js

@@ -0,0 +1,88 @@
+'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;
+
+    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?.();
+            }
+        }, 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());
+    } catch (e) {
+        startFallback();
+    }
+
+    // Fallback: poll every 10 seconds if ip monitor unavailable
+    let pollTimer = null;
+    function startFallback() {
+        monitor = null;
+        pollTimer = setInterval(handleChange, 10000);
+    }
+
+    return function stop() {
+        stopped = true;
+        clearTimeout(debounce);
+        clearInterval(pollTimer);
+        monitor?.kill();
+    };
+}
+
+/**
+ * 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(); }
+            });
+        });
+    });
+}
+
+module.exports = { watchNetwork, waitForInternet, checkInternet };