ani-auto 1.2.5 → 1.3.1

package/src/cli.js

@@ -8,10 +8,10 @@ const chalk       = require('chalk');
 const ora         = require('ora');
 
 const { loadConfig, updateConfig, CONFIG_FILE } = require('./config');
-const db          = require('./db');
+const db           = require('./db');
 const { runCycle } = require('./engine');
 const { getViewer } = require('./anilist');
-const { version } = require('../package.json');
+const { version }  = require('../package.json');
 
 function banner() {
     console.log(chalk.bold.red(`
@@ -25,6 +25,8 @@ function banner() {
        `));
 }
 
+// ── setup ─────────────────────────────────────────────────────────────────
+
 program
     .command('setup')
     .description('Interactive first-time configuration wizard')
@@ -39,7 +41,7 @@ program
             default: current.anilistUsername || '',
         }]);
 
-        let anilistToken = current.anilistToken || '';
+        let anilistToken  = current.anilistToken  || '';
         let watchStatuses = current.watchStatuses || ['CURRENT'];
 
         if (anilistUsername) {
@@ -86,12 +88,11 @@ program
         }
 
         const answers = await inquirer.prompt([
-            { type: 'list',   name: 'quality',               message: 'Default download quality:', choices: ['1080p', '720p', '480p', '360p'], default: current.quality || '1080p' },
-            { type: 'list',   name: 'language',              message: 'Default audio language:',   choices: ['sub', 'dub'], default: current.language || 'sub' },
-            { 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: 'list',   name: 'quality',               message: 'Default download quality:', choices: ['1080p', '720p', '360p'], default: current.quality || '1080p' },
+            { 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 || '' },
+            { type: 'number', name: 'daemonIntervalMinutes', message: 'Daemon fallback interval (minutes):', default: current.daemonIntervalMinutes || 120 },
+            { 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;
@@ -100,106 +101,106 @@ program
         if (answers.anilistToken) {
             const spinner = ora('Verifying AniList token...').start();
             try { const viewer = await getViewer(answers.anilistToken); spinner.succeed(`Logged in as ${chalk.bold(viewer.name)}`); }
-            catch { spinner.warn('Could not verify token — saved anyway, check it manually.'); }
+            catch { spinner.warn('Could not verify token - saved anyway, check it manually.'); }
         }
 
         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,
+            concurrency:           answers.concurrency,
+            outputDir:             answers.outputDir,
             daemonIntervalMinutes: answers.daemonIntervalMinutes,
-            telegramChatId:   answers.telegramChatId  || null,
+            telegramChatId:        answers.telegramChatId  || null,
         });
 
-        console.log(chalk.green(`\n  ✔  Config saved to ${CONFIG_FILE}\n`));
-        console.log(`  Run ${chalk.bold('ani-auto check')} to do a manual download cycle.`);
-        console.log(`  Run ${chalk.bold('ani-auto daemon')} to start the background daemon.\n`);
+        console.log(chalk.green(`\n  Done  Config saved to ${CONFIG_FILE}\n`));
+        console.log(`  Run ${chalk.bold('ani-auto download')} to start downloading.`);
+        console.log(`  Run ${chalk.bold('ani-auto daemon install')} to set up the background service.\n`);
     });
 
+// ── download ──────────────────────────────────────────────────────────────
+
 program
-    .command('check')
+    .command('download')
     .description('Run one download cycle immediately')
-    .option('--auto', 'Skip prompts, auto-select all anime and best site match')
-    .action(async (opts) => {
+    .action(async () => {
         banner();
         try {
-            const config = loadConfig();
-            let quality      = config.quality       || '1080p';
-            let language     = config.language      || 'sub';
-            let range        = null;
-            let runStatuses  = config.watchStatuses || ['CURRENT'];
-
-            if (!opts.auto) {
-                const { pickedQuality, saveAsDefault } = await inquirer.prompt([
-                    {
-                        type:    'list',
-                        name:    'pickedQuality',
-                        message: 'Quality for this run:',
-                        choices: ['1080p', '720p', '480p', '360p'],
-                        default: quality,
-                    },
-                    {
-                        type:    'confirm',
-                        name:    'saveAsDefault',
-                        message: 'Save as default quality?',
-                        default: false,
-                    },
-                ]);
-                quality = pickedQuality;
-                if (saveAsDefault) {
-                    updateConfig({ quality });
-                    console.log(chalk.green(`  ✔  Saved default quality: ${quality}\n`));
-                }
-
-                const { pickedStatuses } = await inquirer.prompt([{
-                    type:    'checkbox',
-                    name:    'pickedStatuses',
-                    message: 'AniList statuses to fetch for this run:',
-                    choices: [
-                        { name: 'CURRENT   (Watching)',      value: 'CURRENT',   checked: (config.watchStatuses || ['CURRENT']).includes('CURRENT') },
-                        { name: 'PLANNING  (Plan to Watch)', value: 'PLANNING',  checked: (config.watchStatuses || []).includes('PLANNING') },
-                        { name: 'PAUSED',                    value: 'PAUSED',    checked: (config.watchStatuses || []).includes('PAUSED') },
-                        { name: 'REPEATING',                 value: 'REPEATING', checked: (config.watchStatuses || []).includes('REPEATING') },
-                    ],
-                    validate: v => v.length > 0 ? true : 'Select at least one status',
-                }]);
-                runStatuses = pickedStatuses;
-
-                const { useRange } = await inquirer.prompt([{
+            const config    = loadConfig();
+            let quality     = config.quality       || '1080p';
+            let language    = config.language      || 'sub';
+            let range       = null;
+            let runStatuses = config.watchStatuses || ['CURRENT'];
+
+            const { pickedQuality, saveAsDefault } = await inquirer.prompt([
+                {
+                    type:    'list',
+                    name:    'pickedQuality',
+                    message: 'Quality for this run:',
+                    choices: ['1080p', '720p', '360p'],
+                    default: quality,
+                },
+                {
                     type:    'confirm',
-                    name:    'useRange',
-                    message: 'Download a specific episode range?',
+                    name:    'saveAsDefault',
+                    message: 'Save as default quality?',
                     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)';
+                },
+            ]);
+            quality = pickedQuality;
+            if (saveAsDefault) {
+                updateConfig({ quality });
+                console.log(chalk.green(`  Done  Saved default quality: ${quality}\n`));
+            }
+
+            const { pickedStatuses } = await inquirer.prompt([{
+                type:    'checkbox',
+                name:    'pickedStatuses',
+                message: 'AniList statuses to fetch for this run:',
+                choices: [
+                    { name: 'CURRENT   (Watching)',      value: 'CURRENT',   checked: (config.watchStatuses || ['CURRENT']).includes('CURRENT') },
+                    { name: 'PLANNING  (Plan to Watch)', value: 'PLANNING',  checked: (config.watchStatuses || []).includes('PLANNING') },
+                    { name: 'PAUSED',                    value: 'PAUSED',    checked: (config.watchStatuses || []).includes('PAUSED') },
+                    { name: 'REPEATING',                 value: 'REPEATING', checked: (config.watchStatuses || []).includes('REPEATING') },
+                ],
+                validate: v => v.length > 0 ? true : 'Select at least one status',
+            }]);
+            runStatuses = pickedStatuses;
+
+            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;
                         }
-                    }]);
-                    range = rangeInput.trim();
-                }
+                        return 'Enter a number (e.g. 5) or range (e.g. 1-24)';
+                    }
+                }]);
+                range = rangeInput.trim();
             }
 
-            await runCycle({ auto: !!opts.auto, quality, language, range, statuses: runStatuses });
+            await runCycle({ auto: false, quality, language, range, statuses: runStatuses });
         }
         catch (e) { console.error(chalk.red('[ERROR]'), e.message); process.exit(1); }
     });
 
+// ── list ──────────────────────────────────────────────────────────────────
+
 program
     .command('list')
     .description('Show all tracked anime and their episode download status')
@@ -207,8 +208,8 @@ program
         banner();
         await db.initDb();
         const rawDb = db.getDb();
-        const stmt = rawDb.prepare('SELECT * FROM anime');
-        const all = [];
+        const stmt  = rawDb.prepare('SELECT * FROM anime');
+        const all   = [];
         while (stmt.step()) all.push(stmt.getAsObject());
         stmt.free();
 
@@ -223,17 +224,18 @@ program
         for (const row of all) {
             const stats   = db.getEpisodeStats(row.id);
             const enabled = row.enabled ? chalk.green('yes') : chalk.gray('no');
-            const title   = row.title.length > 38 ? row.title.slice(0, 37) + '…' : row.title;
+            const title   = row.title.length > 38 ? row.title.slice(0, 37) + '...' : row.title;
             console.log(`  ${title.padEnd(40)} ${row.source.padEnd(8)} ${enabled.padEnd(16)} ${chalk.green(String(stats.done).padEnd(6))}${chalk.red(stats.failed)}`);
         }
         console.log('');
     });
 
+// ── add ───────────────────────────────────────────────────────────────────
+
 program
     .command('add <title>')
     .description('Search AniList and add an anime to the manual download list')
     .option('-q, --quality <quality>', 'Quality override (e.g. 1080p)', null)
-    .option('-l, --language <lang>',   'Language override (sub/dub)',    null)
     .action(async (title, opts) => {
         banner();
         await db.initDb();
@@ -244,22 +246,30 @@ program
         try { results = await searchAnime(title); spinner.stop(); }
         catch (e) { spinner.fail(`AniList search failed: ${e.message}`); return; }
 
-        if (!results.length) { console.log(chalk.yellow(`  No results found on AniList for ${title}.`)); return; }
+        if (!results.length) { console.log(chalk.yellow(`  No results found on AniList for "${title}".\n`)); return; }
 
         const { picked } = await inquirer.prompt([{
             type: 'list', name: 'picked', message: 'Select the anime:',
             choices: results.map(r => ({
-                name:  `${pickTitle(r.titles)} (${r.year || '?'}) — ${r.episodes ? r.episodes + ' eps' : 'ongoing'} [${r.status}]`,
+                name:  `${pickTitle(r.titles)} (${r.year || '?'}) - ${r.episodes ? r.episodes + ' eps' : 'ongoing'} [${r.status}]`,
                 value: r,
             })),
         }]);
 
         const resolvedTitle = pickTitle(picked.titles);
-        const config     = loadConfig();
-        const manualList = config.manualList || [];
+        const config        = loadConfig();
+        const manualList    = config.manualList || [];
 
         const existsManual = manualList.find(m => m.title.toLowerCase() === resolvedTitle.toLowerCase());
-        if (existsManual) { console.log(chalk.yellow(`  "${resolvedTitle}" is already in your manual list.`)); return; }
+        if (existsManual) {
+            if (opts.quality) {
+                db.setAnimeQuality(resolvedTitle, opts.quality);
+                console.log(chalk.green(`\n  Done  Quality for "${resolvedTitle}" set to ${opts.quality}.\n`));
+            } else {
+                console.log(chalk.yellow(`  "${resolvedTitle}" is already in your manual list.\n`));
+            }
+            return;
+        }
 
         // Check if already in AniList watch list (fuzzy match)
         const normalize = s => s.toLowerCase().replace(/[^a-z0-9]/g, '');
@@ -275,34 +285,40 @@ program
                 const inAnilist = anilistEntries.find(e => {
                     const t = e.titles;
                     return [t.english, t.romaji, t.native].some(
-                        title => title && normalize(title) === normResolved
+                        t2 => t2 && normalize(t2) === normResolved
                     );
                 });
                 if (inAnilist) {
-                    console.log(chalk.yellow(`  "${resolvedTitle}" is already in your AniList list (${inAnilist.status}) — no need to add manually.`));
+                    if (opts.quality) {
+                        db.setAnimeQuality(resolvedTitle, opts.quality);
+                        console.log(chalk.green(`\n  Done  Quality for "${resolvedTitle}" set to ${opts.quality}.\n`));
+                    } else {
+                        console.log(chalk.yellow(`  "${resolvedTitle}" is already in your AniList list (${inAnilist.status}) - no need to add manually.\n`));
+                    }
                     return;
                 }
             } catch (e) {}
         }
 
-        const entry = { title: resolvedTitle, anilistId: picked.anilistId, enabled: true, quality: opts.quality || null, language: opts.language || null };
+        const entry = { title: resolvedTitle, anilistId: picked.anilistId, enabled: true, quality: opts.quality || null, language: null };
         manualList.push(entry);
         updateConfig({ manualList });
-        db.upsertAnime({ title: resolvedTitle, siteId: resolvedTitle, anilistId: picked.anilistId, source: 'manual', quality: entry.quality, language: entry.language });
+        db.upsertAnime({ title: resolvedTitle, siteId: resolvedTitle, anilistId: picked.anilistId, source: 'manual', quality: entry.quality, language: null });
 
-        console.log(chalk.green(`\n  ✔  Added ${resolvedTitle} to manual list.`));
-        if (opts.quality)  console.log(`     Quality:  ${opts.quality}`);
-        if (opts.language) console.log(`     Language: ${opts.language}`);
+        console.log(chalk.green(`\n  Done  Added "${resolvedTitle}" to manual list.`));
+        if (opts.quality) console.log(`       Quality: ${opts.quality}`);
         console.log('');
     });
 
+// ── remove ────────────────────────────────────────────────────────────────
+
 program
     .command('remove [title]')
     .description('Remove an anime from the manual list (interactive if no title given)')
     .action(async (title) => {
         banner();
         await db.initDb();
-        const config = loadConfig();
+        const config     = loadConfig();
         const manualList = config.manualList || [];
 
         if (!manualList.length) { console.log(chalk.yellow('  Your manual list is empty.\n')); return; }
@@ -319,17 +335,22 @@ program
         const exists = manualList.find(m => m.title.toLowerCase() === target.toLowerCase());
         if (!exists) { console.log(chalk.yellow(`  "${target}" is not in your manual list.\n`)); return; }
 
-        const { confirm } = await inquirer.prompt([{ type: 'confirm', name: 'confirm', message: `Remove "${target}" and all its episode history?`, default: false }]);
+        const { confirm } = await inquirer.prompt([{
+            type: 'confirm', name: 'confirm',
+            message: `Remove "${target}" and all its episode history?`, default: false,
+        }]);
         if (!confirm) return;
 
         updateConfig({ manualList: manualList.filter(m => m.title.toLowerCase() !== target.toLowerCase()) });
         db.removeAnime(target);
-        console.log(chalk.green(`  ✔  Removed "${target}".\n`));
+        console.log(chalk.green(`\n  Done  Removed "${target}".\n`));
     });
 
+// ── enable / disable ──────────────────────────────────────────────────────
+
 async function pickFromWatchList(message) {
     const { resolveWatchList } = require('./engine');
-    const config = loadConfig();
+    const config    = loadConfig();
     const watchList = await resolveWatchList(config);
 
     if (!watchList.length) { console.log(chalk.yellow('  Watch list is empty.\n')); return null; }
@@ -357,7 +378,7 @@ program
         const item = await pickFromWatchList('Select anime to enable:');
         if (!item) return;
         db.setAnimeEnabled(item.title, true);
-        console.log(chalk.green(`\n  ✔  Enabled "${item.title}".\n`));
+        console.log(chalk.green(`\n  Done  Enabled "${item.title}".\n`));
     });
 
 program
@@ -368,18 +389,51 @@ program
         const item = await pickFromWatchList('Select anime to disable:');
         if (!item) return;
         db.setAnimeEnabled(item.title, false);
-        console.log(chalk.yellow(`\n  ✔  Disabled "${item.title}".\n`));
+        console.log(chalk.yellow(`\n  Done  Disabled "${item.title}".\n`));
     });
 
+// ── status ────────────────────────────────────────────────────────────────
+
 program
     .command('status')
-    .description('Show recent run log')
-    .option('-n, --runs <n>', 'Number of recent runs to show', '10')
+    .description('Show recent run log or per-anime episode breakdown')
+    .option('-n, --runs <n>',    'Number of recent runs to show', '10')
+    .option('--anime <title>',   'Show episode breakdown for a specific anime')
     .action(async (opts) => {
         banner();
         await db.initDb();
+
+        if (opts.anime) {
+            const row = db.getAnimeBySiteTitle(opts.anime);
+            if (!row) {
+                console.log(chalk.yellow(`  "${opts.anime}" not found. Run ani-auto list to see tracked anime.\n`));
+                return;
+            }
+            const episodes = db.getAllEpisodes(row.id);
+            if (!episodes.length) {
+                console.log(chalk.yellow(`  No episodes tracked for "${opts.anime}" yet.\n`));
+                return;
+            }
+            const title = row.anilist_title || row.title;
+            console.log(chalk.bold(`\n  ${title}\n`));
+            console.log(chalk.bold(`  ${'EP'.padEnd(6)} ${'Status'.padEnd(14)} ${'Filename'.padEnd(45)} Downloaded`));
+            console.log('  ' + '─'.repeat(85));
+            for (const ep of episodes) {
+                const status = ep.status === 'done'
+                    ? chalk.green('done')
+                    : ep.status === 'failed'
+                    ? chalk.red('failed')
+                    : chalk.gray(ep.status);
+                const filename = ep.filename ? ep.filename.slice(0, 43) : '-';
+                const date     = ep.downloaded_at ? ep.downloaded_at.slice(0, 10) : '-';
+                console.log(`  ${String(ep.episode_num).padEnd(6)} ${status.padEnd(22)} ${filename.padEnd(45)} ${date}`);
+            }
+            console.log('');
+            return;
+        }
+
         const runs = db.getRecentRuns(parseInt(opts.runs, 10));
-        if (!runs.length) { console.log(chalk.yellow('  No runs recorded yet. Run `ani-auto check` to start.\n')); return; }
+        if (!runs.length) { console.log(chalk.yellow('  No runs recorded yet. Run ani-auto download to start.\n')); return; }
 
         console.log(chalk.bold(`  ${'Time'.padEnd(20)} ${'Downloaded'.padEnd(12)} ${'Skipped'.padEnd(10)} Failed`));
         console.log('  ' + '─'.repeat(55));
@@ -389,24 +443,25 @@ program
         console.log('');
     });
 
+// ── config ────────────────────────────────────────────────────────────────
+
 program
     .command('config')
     .description('View, update, or open config file')
-    .option('--open',                   'Open config file in default editor')
-    .option('--set-quality <quality>',  'Set default quality (e.g. 1080p)')
-    .option('--set-language <lang>',    'Set default language (sub/dub)')
-    .option('--set-concurrency <n>',    'Set parallel download count')
-    .option('--set-output <dir>',       'Set output directory')
-    .option('--set-interval <minutes>', 'Set daemon polling interval')
-    .option('--set-cron <schedule>',    'Set cron schedule (e.g. "0 */2 * * *")')
+    .option('--open',                    'Open config file in default editor')
+    .option('--set-quality <quality>',   'Set default quality (e.g. 1080p)')
+    .option('--set-concurrency <n>',     'Set parallel download count')
+    .option('--set-output <dir>',        'Set output directory')
+    .option('--set-interval <minutes>',  'Set daemon fallback interval in minutes')
+    .option('--set-airing-buffer <min>', 'Set airing buffer in minutes (default: 5)')
     .action((opts) => {
         banner();
 
         if (opts.open) {
-            const { execSync } = require('child_process');
+            const { execSync }    = require('child_process');
             const { getConfigPath } = require('./config');
-            const configPath = getConfigPath();
-            const editor = process.env.EDITOR || process.env.VISUAL || 'nano';
+            const configPath      = getConfigPath();
+            const editor          = process.env.EDITOR || process.env.VISUAL || 'nano';
             console.log(chalk.cyan(`  Opening config in ${editor}: ${configPath}\n`));
             try { execSync(`${editor} "${configPath}"`, { stdio: 'inherit' }); }
             catch (e) { console.log(chalk.yellow(`  Could not open editor. Config is at: ${configPath}`)); }
@@ -414,16 +469,15 @@ program
         }
 
         const updates = {};
-        if (opts.setQuality)     updates.quality               = opts.setQuality;
-        if (opts.setLanguage)    updates.language              = opts.setLanguage;
-        if (opts.setConcurrency) updates.concurrency           = parseInt(opts.setConcurrency, 10);
-        if (opts.setOutput)      updates.outputDir             = opts.setOutput;
-        if (opts.setInterval)    updates.daemonIntervalMinutes = parseInt(opts.setInterval, 10);
-        if (opts.setCron)        updates.cronSchedule          = opts.setCron;
+        if (opts.setQuality)      updates.quality               = opts.setQuality;
+        if (opts.setConcurrency)  updates.concurrency           = parseInt(opts.setConcurrency, 10);
+        if (opts.setOutput)       updates.outputDir             = opts.setOutput;
+        if (opts.setInterval)     updates.daemonIntervalMinutes = parseInt(opts.setInterval, 10);
+        if (opts.setAiringBuffer) updates.airingBufferMinutes   = parseInt(opts.setAiringBuffer, 10);
 
         if (Object.keys(updates).length) {
             updateConfig(updates);
-            console.log(chalk.green('  ✔  Config updated:\n'));
+            console.log(chalk.green('  Done  Config updated:\n'));
             for (const [k, v] of Object.entries(updates)) console.log(`     ${chalk.bold(k)}: ${v}`);
         } else {
             const config = loadConfig();
@@ -436,14 +490,157 @@ program
         console.log('');
     });
 
-// ── update ───────────────────────────────────────────────────────────────
+// ── retry ─────────────────────────────────────────────────────────────────
+
+program
+    .command('retry')
+    .description('Re-attempt all failed episode downloads')
+    .action(async () => {
+        banner();
+        await db.initDb();
+        const failed = db.getFailedEpisodes();
+
+        if (!failed.length) {
+            console.log(chalk.green('  No failed episodes found.\n'));
+            return;
+        }
+
+        const byAnime = {};
+        for (const ep of failed) {
+            const key = ep.anilist_title || ep.title;
+            if (!byAnime[key]) byAnime[key] = { episodes: [] };
+            byAnime[key].episodes.push(ep);
+        }
+
+        console.log(chalk.bold('\n  Failed episodes:'));
+        Object.entries(byAnime).forEach(([title, { episodes }], i) => {
+            console.log(`  ${chalk.cyan(i + 1)}. ${title} - ${chalk.red(episodes.length + ' failed')}`);
+        });
+        console.log(`  ${chalk.cyan('a')}. Retry all\n`);
+
+        const { input } = await inquirer.prompt([{
+            type: 'input', name: 'input',
+            message: 'Select anime to retry (e.g. 1,2 or "a" for all):',
+            default: 'a',
+            validate: v => {
+                if (v.trim().toLowerCase() === 'a') return true;
+                const nums = v.split(',').map(s => parseInt(s.trim()));
+                if (nums.some(isNaN)) return 'Enter numbers or "a"';
+                return true;
+            }
+        }]);
+
+        const keys     = Object.keys(byAnime);
+        const selected = input.trim().toLowerCase() === 'a'
+            ? keys
+            : input.split(',').map(s => keys[parseInt(s.trim()) - 1]).filter(Boolean);
+
+        for (const key of selected) {
+            const { episodes } = byAnime[key];
+            for (const ep of episodes) {
+                db.markEpisodeStatus(ep.anime_id, ep.episode_num, 'pending', null, null);
+            }
+            console.log(chalk.cyan(`  Reset ${episodes.length} episode(s) for ${key}`));
+        }
+
+        console.log(chalk.green('\n  Done - run ani-auto download to re-attempt them.\n'));
+    });
+
+// ── quality ───────────────────────────────────────────────────────────────
+
+program
+    .command('quality [title] [quality]')
+    .description('Set per-anime quality override (interactive if no args given)')
+    .action(async (title, quality) => {
+        banner();
+        await db.initDb();
+
+        if (!title) {
+            const { resolveWatchList } = require('./engine');
+            const config    = loadConfig();
+            const watchList = await resolveWatchList(config);
+
+            if (!watchList.length) { console.log(chalk.yellow('  Watch list is empty.\n')); return; }
+
+            console.log(chalk.bold('\n  Select anime:'));
+            watchList.forEach((item, i) => console.log(`  ${chalk.cyan(i + 1)}. ${item.title}`));
+            console.log('');
+
+            const { idx } = await inquirer.prompt([{
+                type: 'input', name: 'idx', message: 'Enter number:',
+                validate: v => {
+                    const n = parseInt(v.trim());
+                    return (isNaN(n) || n < 1 || n > watchList.length) ? `Enter 1-${watchList.length}` : true;
+                }
+            }]);
+            title = watchList[parseInt(idx.trim()) - 1].title;
+        }
+
+        if (!quality) {
+            const { picked } = await inquirer.prompt([{
+                type: 'list', name: 'picked',
+                message: `Quality for "${title}":`,
+                choices: [
+                    { name: '1080p',              value: '1080p' },
+                    { name: '720p',               value: '720p' },
+                    { name: '360p',               value: '360p' },
+                    { name: 'Use global default', value: null },
+                ],
+            }]);
+            quality = picked;
+        }
+
+        const ok = db.setAnimeQuality(title, quality);
+        if (ok) {
+            console.log(chalk.green(`\n  Done  Quality for "${title}" set to ${quality || 'global default'}.\n`));
+        } else {
+            console.log(chalk.yellow(`\n  "${title}" not found in DB - run ani-auto download first to track it.\n`));
+        }
+    });
+
+// ── notify ────────────────────────────────────────────────────────────────
+
+program
+    .command('notify [action]')
+    .description('Enable or disable Telegram notifications (on, off)')
+    .action(async (action) => {
+        banner();
+        const config = loadConfig();
+
+        if (!action) {
+            const enabled = !!config.telegramChatId && config.telegramNotify !== false;
+            console.log(`  Telegram notifications: ${enabled ? chalk.green('enabled') : chalk.gray('disabled')}`);
+            if (!config.telegramChatId) console.log(chalk.yellow('  No chat ID set - run ani-auto setup to configure.\n'));
+            else console.log('');
+            return;
+        }
+
+        switch (action.toLowerCase()) {
+            case 'on':
+                if (!config.telegramChatId) {
+                    console.log(chalk.yellow('  No chat ID set - run ani-auto setup first.\n'));
+                    return;
+                }
+                updateConfig({ telegramNotify: true });
+                console.log(chalk.green('  Done  Telegram notifications enabled.\n'));
+                break;
+            case 'off':
+                updateConfig({ telegramNotify: false });
+                console.log(chalk.yellow('  Done  Telegram notifications disabled.\n'));
+                break;
+            default:
+                console.log(chalk.yellow(`  Unknown action "${action}". Use: on, off\n`));
+        }
+    });
+
+// ── update ────────────────────────────────────────────────────────────────
 
 program
     .command('update')
     .description('Check for updates and install the latest version')
     .action(async () => {
         banner();
-        const fetch = require('node-fetch');
+        const fetch        = require('node-fetch');
         const { execSync } = require('child_process');
 
         const spinner = ora('Checking for updates...').start();
@@ -454,7 +651,7 @@ program
             spinner.stop();
 
             if (latest === version) {
-                console.log(chalk.green(`  ✔  Already on the latest version (v${version}).\n`));
+                console.log(chalk.green(`  Done  Already on the latest version (v${version}).\n`));
                 return;
             }
 
@@ -462,18 +659,15 @@ program
             console.log(chalk.cyan(`  Latest version:  ${chalk.bold(latest)}\n`));
 
             const { confirm } = await inquirer.prompt([{
-                type:    'confirm',
-                name:    'confirm',
-                message: `Update to v${latest}?`,
-                default: true,
+                type: 'confirm', name: 'confirm',
+                message: `Update to v${latest}?`, default: true,
             }]);
-
             if (!confirm) return;
 
             const installing = ora(`Installing v${latest}...`).start();
             try {
                 execSync('npm install -g ani-auto@latest', { stdio: 'pipe' });
-                installing.succeed(`Updated to v${latest} — restart your terminal to use the new version.`);
+                installing.succeed(`Updated to v${latest} - restart your terminal to use the new version.`);
             } catch (e) {
                 installing.fail('Update failed. Try manually: npm install -g ani-auto@latest');
             }
@@ -486,15 +680,95 @@ program
 // ── daemon ────────────────────────────────────────────────────────────────
 
 program
-    .command('daemon')
-    .description('Start the background daemon')
-    .option('--auto', 'Skip prompts, auto-select all (default: true for daemon)')
-    .action(() => { require('./daemon'); });
+    .command('daemon [action]')
+    .description('Manage the background daemon (install, start, stop, restart, status, logs)')
+    .action(async (action) => {
+        const { spawnSync, spawn } = require('child_process');
+        const SERVICE = 'ani-auto';
+
+        const run = (cmd) => {
+            try {
+                const r = spawnSync(cmd, { shell: true, encoding: 'utf8' });
+                return { out: r.stdout?.trim(), err: r.stderr?.trim(), code: r.status };
+            } catch (e) {
+                return { out: '', err: e.message, code: 1 };
+            }
+        };
+
+        if (!action) { require('./daemon'); return; }
+
+        switch (action.toLowerCase()) {
+            case 'install': {
+                banner();
+                const nodeBin    = run('which node').out;
+                const daemonPath = run('npm root -g').out + '/ani-auto/src/daemon.js';
+                const service    = [
+                    '[Unit]',
+                    'Description=ani-auto daemon',
+                    'After=network-online.target',
+                    '',
+                    '[Service]',
+                    `ExecStart=${nodeBin} ${daemonPath}`,
+                    'Restart=on-failure',
+                    'RestartSec=10',
+                    '',
+                    '[Install]',
+                    'WantedBy=default.target',
+                ].join('\n');
+
+                const fs   = require('fs');
+                const os   = require('os');
+                const path = require('path');
+                const dir  = path.join(os.homedir(), '.config', 'systemd', 'user');
+                fs.mkdirSync(dir, { recursive: true });
+                fs.writeFileSync(path.join(dir, `${SERVICE}.service`), service);
+
+                run('systemctl --user daemon-reload');
+                run(`systemctl --user enable ${SERVICE}`);
+                run(`systemctl --user start ${SERVICE}`);
+                console.log(chalk.green(`\n  Done  Daemon installed and started.`));
+                console.log(chalk.gray(`  Run ${chalk.bold('ani-auto daemon status')} to check.\n`));
+                break;
+            }
+            case 'start': {
+                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`));
+                break;
+            }
+            case 'stop': {
+                const r = run(`systemctl --user stop ${SERVICE}`);
+                if (r.code === 0) console.log(chalk.yellow('\n  Done  Daemon stopped.\n'));
+                else console.log(chalk.red(`\n  Failed to stop: ${r.err}\n`));
+                break;
+            }
+            case 'restart': {
+                const r = run(`systemctl --user restart ${SERVICE}`);
+                if (r.code === 0) console.log(chalk.green('\n  Done  Daemon restarted.\n'));
+                else console.log(chalk.red(`\n  Failed to restart: ${r.err}\n`));
+                break;
+            }
+            case 'status': {
+                const r = run(`systemctl --user status ${SERVICE}`);
+                console.log(r.out || r.err);
+                break;
+            }
+            case 'logs': {
+                console.log(chalk.gray('\n  Streaming logs (Ctrl+C to stop)...\n'));
+                spawn('journalctl', ['--user', '-u', SERVICE, '-f'], { stdio: 'inherit' });
+                break;
+            }
+            default:
+                console.log(chalk.yellow(`\n  Unknown action "${action}". Use: install, start, stop, restart, status, logs\n`));
+        }
+    });
+
+// ── main ──────────────────────────────────────────────────────────────────
 
 program
     .name('ani-auto')
     .version(version)
-    .description('Automatic anime episode downloader — AniList-aware')
+    .description('Automatic anime episode downloader - AniList-aware')
     .parse(process.argv);
 
 if (!process.argv.slice(2).length) { banner(); program.help(); }