ani-auto 1.3.1 → 1.3.3

package/CHANGELOG.md

@@ -0,0 +1,82 @@
+# 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

package/README.md

@@ -10,7 +10,7 @@
 
 # ani-auto
 
-automatically downloads new anime episodes based on your anilist watching list.
+automatically downloads new anime episodes. works with your AniList watching list or a manual list — no account required.
 
 ---
 
@@ -26,28 +26,42 @@ npm install -g ani-auto
 
 ```bash
 ani-auto setup
-ani-auto check
+ani-auto download
 ```
 
+> **Tip:** connecting your AniList account lets the daemon know exactly when episodes air and download them automatically. without AniList, you can still add anime manually and the daemon will check every 2 hours.
+
 ---
 
 ## features
 
 **1. anilist sync**
-stays in sync with your watching list — only downloads episodes you haven't seen yet.
+stays in sync with your watching list — only downloads episodes you haven't seen yet. supports multiple statuses (watching, paused, planning, repeating).
 
-**2. quality control**
-choose your preferred quality on each run or set a default.
+**2. manual list**
+no AniList account? add any anime manually with `ani-auto add "title"` and it will be tracked and downloaded just like AniList entries.
 
-**3. background daemon**
-set it and forget it — checks for new episodes automatically on a schedule.
+**3. quality control**
+choose your preferred quality on each run or set a default. set a different quality per anime with `ani-auto quality`.
 
-**4. pause & resume**
-disable any anime at any time without losing your download history.
+**4. smart daemon**
+connects to your AniList to know exactly when each episode airs and downloads at the right time. falls back to checking every 2 hours for manual list entries or when AniList is not connected.
+
+**5. offline recovery**
+if your device loses internet, the daemon detects it instantly and resumes the moment connection is restored.
+
+**6. episode range**
+download a specific range of episodes in one run — useful for catching up on a series.
 
-**5. telegram notifications**
+**7. 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`.
 
+**8. pause & resume**
+disable any anime at any time without losing your download history.
+
+**9. retry failed episodes**
+re-attempt all failed downloads in one command with `ani-auto retry`.
+
 ---
 
 ## commands
@@ -55,22 +69,22 @@ get notified on your phone when episodes download, fail, or the daemon starts. m
 ```
 Usage: ani-auto [options] [command]
 
-Automatic anime episode downloader — AniList-aware
-
 Options:
   -V, --version          output the version number
   -h, --help             display help for command
 
 Commands:
   setup                  Interactive first-time configuration wizard
-  check [options]        Run one download cycle immediately
+  download               Run one download cycle immediately
   list                   Show all tracked anime and their episode download status
-  add [options] <title>  Search AniList and add an anime to the manual download list
-  remove [title]         Remove an anime from the manual list (interactive if no title given)
+  add [options] <title>  Search AniList and add an anime to the manual list
+  remove [title]         Remove an anime from the manual list
   enable                 Re-enable downloads for an anime
   disable                Pause downloads for an anime (keeps history)
+  quality [title]        Set per-anime quality override
+  retry                  Re-attempt all failed episode downloads
+  status [options]       Show recent run log or per-anime episode breakdown
   notify [action]        Enable or disable Telegram notifications (on, off)
-  status [options]       Show recent run log
   config [options]       View, update, or open config file
   update                 Check for updates and install the latest version
   daemon [action]        Manage the background daemon (install, start, stop, restart, status, logs)
@@ -85,7 +99,8 @@ Commands:
 ani-auto config --set-quality 1080p
 ani-auto config --set-concurrency 3
 ani-auto config --set-output ~/videos/anime
-ani-auto config --set-interval 60
+ani-auto config --set-interval 120
+ani-auto config --set-airing-buffer 5
 ani-auto config --open
 ```
 
@@ -102,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,6 +1,6 @@
 {
   "name": "ani-auto",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "description": "Automatic anime episode downloader",
   "bin": {
     "ani-auto": "./src/cli.js"

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';
@@ -749,6 +749,9 @@ program
                 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 +761,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 r = run(`systemctl --user start ${SERVICE}`);
+                if (r.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/config.js

@@ -22,7 +22,8 @@ const DEFAULTS = {
     maxEpisodesPerRun:     50,
     telegramChatId:        null,         
     telegramNotify:        true,         
-    airingBufferMinutes:   5,            // minutes after air time before checking AnimePahe
+    airingBufferMinutes:   5,
+    daemonEnabled:         true,         // set to false via `ani-auto daemon disable`
 };
 
 function ensureConfigDir() {

package/src/daemon.js

@@ -85,8 +85,24 @@ 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) {
+        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);
+    }
+
+    const intervalMs = (config.daemonIntervalMinutes || 30) * 60 * 1000;
 
     console.log(chalk.bold.red(`
    █████╗ ███╗   ██╗██╗      █████╗ ██╗   ██╗████████╗ ██████╗ 

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

@@ -13,7 +13,6 @@ 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}`); }
@@ -21,7 +20,6 @@ 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} ` : '';
@@ -45,7 +43,6 @@ function detectSeason(title) {
     return m ? parseInt(m[1], 10) : null;
 }
 
-// ── Watch list ─────────────────────────────────────────────────────────────
 
 async function resolveWatchList(config) {
     const items = [];
@@ -103,7 +100,6 @@ async function resolveWatchList(config) {
     });
 }
 
-// ── Anime selector prompt ──────────────────────────────────────────────────
 
 async function promptAnimeSelection(watchList) {
     console.log(chalk.bold('\n  Available anime:'));
@@ -134,7 +130,6 @@ async function promptAnimeSelection(watchList) {
     return indices.map(i => watchList[i]);
 }
 
-// ── 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
@@ -333,7 +328,6 @@ 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();

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,25 +35,21 @@ 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 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);
+    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) {
@@ -69,8 +58,10 @@ async function notifyFailed(animeTitle, episode, error) {
         `<code>━━━━━━━━━━━━━━━</code>\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) {
@@ -81,8 +72,10 @@ async function notifySummary(totals) {
         `✅  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}`);
+    await Promise.allSettled([
+        sendTelegram({ text }),
+        sendDesktop('ani-auto run complete', `Downloaded: ${totals.downloaded}  Failed: ${totals.failed}`)
+    ]);
 }
 
 async function notifyDaemonStart(intervalMinutes, downloadingCount) {
@@ -93,22 +86,17 @@ async function notifyDaemonStart(intervalMinutes, downloadingCount) {
         `📦  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`
-    );
+    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 = { notifyEpisode, notifyFailed, notifySummary, notifyDaemonStart, notifyDaemonStop };

package/src/scraper.js

@@ -1,24 +1,9 @@
 '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');
+const UTILS_PATH = process.env.KANIME_UTILS_PATH || path.resolve(__dirname, '../utils.js');
 
 let _utils = null;
 function utils() {
@@ -26,24 +11,11 @@ function 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}`
-        );
+        throw new Error(`Cannot find utils at "${UTILS_PATH}". Set KANIME_UTILS_PATH env var.\n${e.message}`);
     }
     return _utils;
 }
 
-// ── Public surface ────────────────────────────────────────────────────────
-
-/**
- * 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,24 +24,20 @@ 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(`API returned ${res.status}`);
+        const data = await res.json();
+        return data.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 } });
@@ -78,13 +46,6 @@ async function getEpisodes(animeId) {
     return data.results?.episodes || [];
 }
 
-/**
- * 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();
     const res = await fetch(
@@ -96,15 +57,6 @@ async function getDownloadLinks(animeId, episodeId) {
     return data.results?.downloadLinks || [];
 }
 
-/**
- * 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;
     return (
@@ -114,26 +66,9 @@ function pickLink(links, quality, language) {
     );
 }
 
-/**
- * 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 };