ani-auto 1.0.0

package/src/cli.js

@@ -0,0 +1,517 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * cli.js  —  ani-auto command line interface
+ *
+ * Commands:
+ *   setup              Interactive first-time setup wizard
+ *   check              Run one download cycle immediately
+ *   list               Show all tracked anime
+ *   add  <title>       Add anime to manual list
+ *   remove <title>     Remove anime from manual list
+ *   enable  <title>    Re-enable a disabled entry
+ *   disable <title>    Pause downloads for an anime
+ *   status             Show recent run log + per-anime episode counts
+ *   config             View / edit config values
+ *   daemon             Start the background daemon
+ */
+
+const { program } = require('commander');
+const inquirer    = require('inquirer');
+const chalk       = require('chalk');
+const ora         = require('ora');
+
+const { loadConfig, updateConfig, CONFIG_FILE } = require('./config');
+const db          = require('./db');
+const { runCycle } = require('./engine');
+const { getViewer } = require('./anilist');
+const { version } = require('../package.json');
+
+// ── Banner ────────────────────────────────────────────────────────────────
+
+function banner() {
+       console.log(chalk.bold.red(`
+      █████╗ ███╗   ██╗██╗      █████╗ ██╗   ██╗████████╗ ██████╗ 
+     ██╔══██╗████╗  ██║██║     ██╔══██╗██║   ██║╚══██╔══╝██╔═══██╗
+     ███████║██╔██╗ ██║██║     ███████║██║   ██║   ██║   ██║   ██║
+     ██╔══██║██║╚██╗██║██║     ██╔══██║██║   ██║   ██║   ██║   ██║
+     ██║  ██║██║ ╚████║██║     ██║  ██║╚██████╔╝   ██║   ╚██████╔╝
+     ╚═╝  ╚═╝╚═╝  ╚═══╝╚═╝     ╚═╝  ╚═╝ ╚═════╝    ╚═╝    ╚═════╝ 
+            A N I M E   A U T O   D O W N L O A D E R
+       `));
+       }
+// ── setup ─────────────────────────────────────────────────────────────────
+
+program
+    .command('setup')
+    .description('Interactive first-time configuration wizard')
+    .action(async () => {
+        banner();
+        const current = loadConfig();
+
+        console.log(chalk.cyan('  Let\'s configure your auto-downloader.\n'));
+
+        // Step 1: get username
+        const { anilistUsername } = await inquirer.prompt([{
+            type:    'input',
+            name:    'anilistUsername',
+            message: 'AniList username (leave blank to skip AniList integration):',
+            default: current.anilistUsername || '',
+        }]);
+
+        // Step 2: if username given, open browser THEN ask for token
+        let anilistToken = current.anilistToken || '';
+        let watchStatuses = current.watchStatuses || ['CURRENT'];
+
+        if (anilistUsername) {
+            const { openBrowser } = await inquirer.prompt([{
+                type:    'confirm',
+                name:    'openBrowser',
+                message: 'Open browser to get AniList token?',
+                default: true,
+            }]);
+
+            if (openBrowser) {
+                const url = 'https://anilist.co/api/v2/oauth/authorize?client_id=37183&response_type=token';
+                const { spawn } = require('child_process');
+                const openers = process.platform === 'win32' ? ['start']
+                              : process.platform === 'darwin' ? ['open']
+                              : ['xdg-open', 'firefox'];
+                let opened = false;
+                for (const opener of openers) {
+                    try {
+                        spawn(opener, [url], { stdio: 'ignore', detached: true, env: process.env }).unref();
+                        opened = true;
+                        break;
+                    } catch (e) {}
+                }
+                console.log(chalk.cyan(`\n  ${opened ? 'Browser opened!' : 'Visit:'} ${url}`));
+                console.log(chalk.gray('  Authorize, then copy the token from the URL (the part after access_token=).\n'));
+                await new Promise(r => setTimeout(r, 1500));
+            }
+
+            const tokenAnswer = await inquirer.prompt([{
+                type:    'password',
+                name:    'anilistToken',
+                message: 'Paste your AniList token here:',
+                default: current.anilistToken || '',
+            }]);
+            anilistToken = tokenAnswer.anilistToken;
+
+            const statusAnswer = await inquirer.prompt([{
+                type:    'list',
+                name:    'watchStatuses',
+                message: 'Which AniList status to download?',
+                choices: [
+                    { name: 'CURRENT   (Watching)',      value: 'CURRENT' },
+                    { name: 'PLANNING  (Plan to Watch)', value: 'PLANNING' },
+                    { name: 'PAUSED',                    value: 'PAUSED' },
+                    { name: 'REPEATING',                 value: 'REPEATING' },
+                ],
+                default: (current.watchStatuses || ['CURRENT'])[0],
+                filter:  v => [v],
+            }]);
+            watchStatuses = statusAnswer.watchStatuses;
+        }
+
+        // Step 3: rest of config
+        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: 'input',
+                name: 'outputDir',
+                message: 'Output directory for downloads:',
+                default: current.outputDir,
+            },
+            {
+                type: 'number',
+                name: 'daemonIntervalMinutes',
+                message: 'Daemon polling interval (minutes):',
+                default: current.daemonIntervalMinutes || 30,
+            },
+        ]);
+        answers.anilistUsername = anilistUsername;
+        answers.anilistToken    = anilistToken;
+        answers.watchStatuses   = watchStatuses;
+
+        // Verify AniList token if provided
+        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.');
+            }
+        }
+
+        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,
+            daemonIntervalMinutes: answers.daemonIntervalMinutes,
+        });
+
+        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`);
+    });
+
+// ── check ─────────────────────────────────────────────────────────────────
+
+program
+    .command('check')
+    .description('Run one download cycle immediately')
+    .option('--auto', 'Skip prompts, auto-select all anime and best site match')
+    .action(async (opts) => {
+        banner();
+        try {
+            await runCycle({ auto: !!opts.auto });
+        } 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')
+    .action(async () => {
+        banner();
+        await db.initDb();
+        const rawDb = db.getDb();
+        const stmt = rawDb.prepare('SELECT * FROM anime');
+        const all = [];
+        while (stmt.step()) all.push(stmt.getAsObject());
+        stmt.free();
+
+        if (!all.length) {
+            console.log(chalk.yellow('  No anime tracked yet.'));
+            console.log(`  Use ${chalk.bold('ani-auto add "<title>"')} to add one manually.\n`);
+            return;
+        }
+
+        console.log(chalk.bold(`  ${'Title'.padEnd(40)} ${'Source'.padEnd(8)} ${'Enabled'.padEnd(8)} Done  Failed`));
+        console.log('  ' + '─'.repeat(72));
+
+        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;
+            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();
+
+        const { searchAnime, pickTitle } = require('./anilist');
+        const ora = require('ora');
+
+        const spinner = ora(`Searching AniList for "${title}"...`).start();
+        let results;
+        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;
+        }
+
+        // Let user pick the right match
+        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}]`,
+                value: r,
+            })),
+        }]);
+
+        const resolvedTitle = pickTitle(picked.titles);
+        const config     = loadConfig();
+        const manualList = config.manualList || [];
+
+        const exists = manualList.find(m => m.title.toLowerCase() === resolvedTitle.toLowerCase());
+        if (exists) {
+            console.log(chalk.yellow(`  ${resolvedTitle} is already in your manual list.`));
+            return;
+        }
+
+        const entry = {
+            title:     resolvedTitle,
+            anilistId: picked.anilistId,
+            enabled:   true,
+            quality:   opts.quality  || null,
+            language:  opts.language || null,
+        };
+
+        manualList.push(entry);
+        updateConfig({ manualList });
+        db.upsertAnime({ title: resolvedTitle, siteId: resolvedTitle, anilistId: picked.anilistId, source: 'manual', quality: entry.quality, language: entry.language });
+
+        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('');
+    });
+
+// ── 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 manualList = config.manualList || [];
+
+        if (!manualList.length) {
+            console.log(chalk.yellow('  Your manual list is empty.\n'));
+            return;
+        }
+
+        let target = title;
+
+        // If no title given, show interactive picker
+        if (!target) {
+            const { picked } = await inquirer.prompt([{
+                type:    'list',
+                name:    'picked',
+                message: 'Select anime to remove:',
+                choices: manualList.map(m => ({
+                    name:  `${m.title}${m.enabled ? '' : chalk.gray(' (disabled)')}`,
+                    value: m.title,
+                })),
+            }]);
+            target = picked;
+        }
+
+        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,
+        }]);
+        if (!confirm) return;
+
+        updateConfig({ manualList: manualList.filter(m => m.title.toLowerCase() !== target.toLowerCase()) });
+        db.removeAnime(target);
+        console.log(chalk.green(`  ✔  Removed "${target}".\n`));
+    });
+
+// ── enable / disable ──────────────────────────────────────────────────────
+
+async function pickFromWatchList(message) {
+    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 null;
+    }
+
+    console.log(chalk.bold('\n  Watch list:'));
+    watchList.forEach((item, i) => {
+        console.log(`  ${chalk.cyan(i + 1)}. ${item.title}`);
+    });
+    console.log('');
+
+    const { input } = await inquirer.prompt([{
+        type:     'input',
+        name:     'input',
+        message,
+        validate: (val) => {
+            const n = parseInt(val.trim());
+            if (isNaN(n) || n < 1 || n > watchList.length)
+                return `Enter a number between 1 and ${watchList.length}`;
+            return true;
+        }
+    }]);
+
+    return watchList[parseInt(input.trim()) - 1];
+}
+
+program
+    .command('enable')
+    .description('Re-enable downloads for an anime')
+    .action(async () => {
+        await db.initDb();
+        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`));
+    });
+
+program
+    .command('disable')
+    .description('Pause downloads for an anime (keeps history)')
+    .action(async () => {
+        await db.initDb();
+        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`));
+    });
+
+// ── status ────────────────────────────────────────────────────────────────
+
+program
+    .command('status')
+    .description('Show recent run log')
+    .option('-n, --runs <n>', 'Number of recent runs to show', '10')
+    .action(async (opts) => {
+        banner();
+        await db.initDb();
+        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;
+        }
+
+        console.log(chalk.bold(`  ${'Time'.padEnd(20)} ${'Downloaded'.padEnd(12)} ${'Skipped'.padEnd(10)} Failed`));
+        console.log('  ' + '─'.repeat(55));
+        for (const run of runs) {
+            console.log(
+                `  ${run.ran_at.padEnd(20)} ` +
+                `${chalk.green(String(run.downloaded).padEnd(12))}` +
+                `${chalk.gray(String(run.skipped).padEnd(10))}` +
+                `${chalk.red(run.failed)}`
+            );
+        }
+        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 * * *")')
+    .action((opts) => {
+        banner();
+
+        if (opts.open) {
+            const { execSync } = require('child_process');
+            const { getConfigPath } = require('./config');
+            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}`));
+            }
+            return;
+        }
+
+        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 (Object.keys(updates).length) {
+            const config = updateConfig(updates);
+            console.log(chalk.green('  ✔  Config updated:\n'));
+            for (const [k, v] of Object.entries(updates)) {
+                console.log(`     ${chalk.bold(k)}: ${v}`);
+            }
+        } else {
+            // Print full config
+            const config = loadConfig();
+            console.log(chalk.bold('  Current configuration:\n'));
+            for (const [k, v] of Object.entries(config)) {
+                if (k === 'anilistToken' && v) {
+                    console.log(`  ${chalk.cyan(k.padEnd(26))} ${chalk.gray('[set]')}`);
+                } else {
+                    console.log(`  ${chalk.cyan(k.padEnd(26))} ${JSON.stringify(v)}`);
+                }
+            }
+        }
+        console.log('');
+    });
+
+// ── daemon ────────────────────────────────────────────────────────────────
+
+program
+    .command('daemon')
+    .description('Start the background daemon')
+    .option('--auto', 'Skip prompts, auto-select all (default: true for daemon)')
+    .action(() => {
+        require('./daemon');
+    });
+
+// ── Bootstrap ─────────────────────────────────────────────────────────────
+
+program
+    .name('ani-auto')
+    .version(version)
+    .description('Automatic anime episode downloader — AniList-aware')
+    .parse(process.argv);
+
+if (!process.argv.slice(2).length) {
+    banner();
+    program.help();
+}

package/src/config.js

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

package/src/daemon.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * 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');
+
+let running = false;   // prevents overlapping runs
+
+async function safeRun() {
+    if (running) {
+        console.log(chalk.yellow(`[${ts()}] Previous run still in progress — skipping.`));
+        return;
+    }
+    running = true;
+    try {
+        await runCycle({ auto: true });
+    } catch (e) {
+        console.error(chalk.red(`[${ts()}] Unhandled error in run cycle:`), e.message);
+    } finally {
+        running = false;
+    }
+}
+
+function ts() { return new Date().toISOString().replace('T',' ').slice(0,19); }
+
+async function startDaemon() {
+    const config = loadConfig();
+    const intervalMs = (config.daemonIntervalMinutes || 30) * 60 * 1000;
+    const cronSchedule = config.cronSchedule || '0 */2 * * *';
+
+    console.log(chalk.bold.red(`
+   █████╗ ███╗   ██╗██╗      █████╗ ██╗   ██╗████████╗ ██████╗ 
+  ██╔══██╗████╗  ██║██║     ██╔══██╗██║   ██║╚══██╔══╝██╔═══██╗
+  ███████║██╔██╗ ██║██║     ███████║██║   ██║   ██║   ██║   ██║
+  ██╔══██║██║╚██╗██║██║     ██╔══██║██║   ██║   ██║   ██║   ██║
+  ██║  ██║██║ ╚████║██║     ██║  ██║╚██████╔╝   ██║   ╚██████╔╝
+  ╚═╝  ╚═╝╚═╝  ╚═══╝╚═╝     ╚═╝  ╚═╝ ╚═════╝    ╚═╝    ╚═════╝ 
+            A N I M E   A U T O   D O W N L O A D E R  D A E M O N
+    `));
+
+    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`));
+
+    // Run immediately on start
+    await safeRun();
+
+    // Interval-based polling
+    setInterval(safeRun, 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',  () => { console.log(chalk.yellow('\n  Shutting down daemon...')); process.exit(0); });
+    process.on('SIGTERM', () => { console.log(chalk.yellow('\n  Daemon terminated.')); process.exit(0); });
+}
+
+startDaemon().catch(e => {
+    console.error(chalk.red('[FATAL]'), e.message);
+    process.exit(1);
+});