ani-auto 1.4.3 → 2.0.0

package/src/api/update.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const { Router } = require('express');
+const fetch = require('node-fetch');
+const { exec } = require('child_process');
+const { version } = require('../../package.json');
+
+const router = Router();
+
+router.get('/check', async (req, res) => {
+  try {
+    const response = await fetch('https://registry.npmjs.org/ani-auto/latest', {
+      timeout: 10000,
+    });
+    const data = await response.json();
+    const latest = data.version;
+    res.json({
+      current: version,
+      latest,
+      updateAvailable: latest !== version,
+    });
+  } catch (e) {
+    res.json({
+      current: version,
+      latest: version,
+      updateAvailable: false,
+      error: e.message,
+    });
+  }
+});
+
+router.post('/install', async (req, res) => {
+  const broadcast = req.app.locals.broadcast;
+  if (!broadcast) {
+    return res.status(500).json({ error: 'WebSocket not available' });
+  }
+
+  res.json({ ok: true, message: 'Update started' });
+
+  broadcast('update:progress', { percent: 5, message: 'Checking latest version...' });
+
+  try {
+    const response = await fetch('https://registry.npmjs.org/ani-auto/latest', {
+      timeout: 10000,
+    });
+    const data = await response.json();
+    const latest = data.version;
+
+    if (latest === version) {
+      broadcast('update:done', {
+        version,
+        message: `Already on v${version}`,
+      });
+      return;
+    }
+
+    broadcast('update:progress', {
+      percent: 15,
+      message: `Updating v${version} → v${latest}...`,
+    });
+
+    const child = exec(
+      `npm install -g ani-auto@${latest}`,
+      { timeout: 120000 },
+      (error) => {
+        if (error) {
+          broadcast('update:error', {
+            error: `Install failed: ${error.message}`,
+          });
+          return;
+        }
+        broadcast('update:progress', { percent: 95, message: 'Finalizing...' });
+        setTimeout(() => {
+          broadcast('update:done', {
+            version: latest,
+            message: `Updated to v${latest}`,
+          });
+        }, 500);
+      }
+    );
+
+    child.stdout?.on('data', (chunk) => {
+      const text = chunk.toString();
+      if (text.includes('added') || text.includes('changed')) {
+        broadcast('update:progress', {
+          percent: 60,
+          message: 'Packages installed',
+        });
+      }
+    });
+  } catch (e) {
+    broadcast('update:error', { error: e.message });
+  }
+});
+
+module.exports = router;

package/src/cli.js

@@ -100,13 +100,19 @@ 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.'); }
+            try {
+                const viewer = await getViewer(answers.anilistToken);
+                spinner.succeed(`Logged in as ${chalk.bold(viewer.name)}`);
+                answers.anilistAvatar = viewer.avatar?.medium || null;
+            } catch {
+                spinner.warn('Could not verify token - saved anyway, check it manually.');
+            }
         }
 
         updateConfig({
             anilistUsername:       answers.anilistUsername || null,
             anilistToken:          answers.anilistToken    || null,
+            anilistAvatar:         answers.anilistAvatar   || null,
             watchStatuses:         answers.watchStatuses   || current.watchStatuses,
             quality:               answers.quality,
             concurrency:           answers.concurrency,
@@ -806,6 +812,16 @@ program
         }
     });
 
+// ── web ───────────────────────────────────────────────────────────────────
+
+program
+    .command('web')
+    .description('Start the web UI server on port 2640')
+    .action(() => {
+        const { startServer } = require('./server');
+        startServer();
+    });
+
 // ── main ──────────────────────────────────────────────────────────────────
 
 program

package/src/config.js

@@ -23,18 +23,30 @@ const DEFAULTS = {
     telegramChatId:        null,
     telegramNotify:        true,
     airingBufferMinutes:   5,
-    daemonEnabled:         true,         // set to false via `ani-auto daemon disable`
+    daemonEnabled:         true,
+    autoUpdateCheck:       true,
     apiBaseUrl:            'https://aor-rex-anikuro-api.hf.space',
+    anilistClientId:       '37183',
+    anilistClientSecret:   null,
+    animepaheCfClearance:  null,
+    animepaheUserAgent:    null,
 };
 
 function ensureConfigDir() {
     if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
 }
 
+const SENTINEL = '[set]';
+const MASKABLE_KEYS = new Set(['anilistToken', 'anilistClientSecret', 'animepaheCfClearance', 'animepaheUserAgent']);
+
 function loadConfig() {
     ensureConfigDir();
     if (!fs.existsSync(CONFIG_FILE)) { saveConfig(DEFAULTS); return { ...DEFAULTS }; }
-    try { return { ...DEFAULTS, ...JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')) }; }
+    try {
+        const cfg = { ...DEFAULTS, ...JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')) };
+        for (const k of MASKABLE_KEYS) { if (cfg[k] === SENTINEL) cfg[k] = null; }
+        return cfg;
+    }
     catch { return { ...DEFAULTS }; }
 }
 

package/src/daemon.js

@@ -22,7 +22,7 @@ async function safeRun() {
         return;
     }
 
-    // Check internet before running
+      // Check internet before running
     const online = await checkInternet();
     if (!online) {
         warn('No internet connection — waiting for network...');

package/src/db.js

@@ -117,17 +117,35 @@ function _run(sql, params = []) {
 }
 
 
-function upsertAnime({ title, siteId, anilistId, source, quality, language }) {
-    _run(`
-        INSERT INTO anime (title, site_id, anilist_id, source, quality, language)
-        VALUES (?, ?, ?, ?, ?, ?)
-        ON CONFLICT(site_id) DO UPDATE SET
-            title      = excluded.title,
-            anilist_id = COALESCE(excluded.anilist_id, anime.anilist_id),
-            quality    = COALESCE(excluded.quality, anime.quality),
-            language   = COALESCE(excluded.language, anime.language)
-    `, [title, siteId || title, anilistId || null, source || 'anilist', quality || null, language || null]);
-    return _get('SELECT * FROM anime WHERE site_id = ?', [siteId || title]);
+function upsertAnime({ title, siteId, anilistId, source, quality, language, poster_url }) {
+    const finalSiteId = siteId || title;
+    const finalAnilistId = anilistId || null;
+
+    const existing = finalAnilistId
+        ? (_get('SELECT id FROM anime WHERE anilist_id = ?', [finalAnilistId]) ||
+           _get('SELECT id FROM anime WHERE site_id = ?', [finalSiteId]))
+        : _get('SELECT id FROM anime WHERE site_id = ?', [finalSiteId]);
+
+    if (existing) {
+        _run(`
+            UPDATE anime SET
+                title      = ?,
+                site_id    = ?,
+                anilist_id = COALESCE(?, anime.anilist_id),
+                source     = ?,
+                quality    = COALESCE(?, anime.quality),
+                language   = COALESCE(?, anime.language),
+                poster_url = COALESCE(?, anime.poster_url)
+            WHERE id = ?
+        `, [title, finalSiteId, finalAnilistId, source || 'anilist', quality || null, language || null, poster_url || null, existing.id]);
+    } else {
+        _run(`
+            INSERT INTO anime (title, site_id, anilist_id, source, quality, language, poster_url)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+        `, [title, finalSiteId, finalAnilistId, source || 'anilist', quality || null, language || null, poster_url || null]);
+    }
+    return _get('SELECT * FROM anime WHERE site_id = ?', [finalSiteId]) ||
+           _get('SELECT * FROM anime WHERE anilist_id = ?', [finalAnilistId]);
 }
 
 function getAnime(siteId) {
@@ -263,9 +281,18 @@ function updateNextAiring(animeDbId, airingAt) {
     _run('UPDATE anime SET next_airing_at = ? WHERE id = ?', [airingAt, animeDbId]);
 }
 
+function execSql(sql, params = []) {
+    _run(sql, params);
+}
+
+function saveDb() {
+    _save();
+}
+
 module.exports = {
     initDb,
     getDb: getDbInstance,
+    execSql, saveDb,
     upsertAnime, getAnime, getAnimeBySiteTitle, saveConfirmedSiteMatch, getAllEnabledAnime, setAnimeEnabled, setAnimeQuality, removeAnime,
     isEpisodeDownloaded, getEpisodeRow, markEpisodeStatus, getEpisodeStats, getFailedEpisodes, getAllEpisodes, updateNextAiring,
     logRun, getRecentRuns,

package/src/engine.js

@@ -15,11 +15,14 @@ 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}`); }
-function warn(msg) { console.log(`${chalk.gray(ts())} ${chalk.yellow('⚠')}  ${msg}`); }
-function err(msg)  { console.log(`${chalk.gray(ts())} ${chalk.red('✖')}  ${msg}`); }
+let currentBus = null;
+
+function info(msg) { const m = stripAnsi(msg); console.log(`${chalk.gray(ts())} ${chalk.cyan('ℹ')}  ${msg}`); if (currentBus) currentBus.emit('broadcast', 'log', { level: 'info', message: m, timestamp: ts() }); }
+function ok(msg)   { const m = stripAnsi(msg); console.log(`${chalk.gray(ts())} ${chalk.green('✔')}  ${msg}`); if (currentBus) currentBus.emit('broadcast', 'log', { level: 'ok', message: m, timestamp: ts() }); }
+function warn(msg) { const m = stripAnsi(msg); console.log(`${chalk.gray(ts())} ${chalk.yellow('⚠')}  ${msg}`); if (currentBus) currentBus.emit('broadcast', 'log', { level: 'warn', message: m, timestamp: ts() }); }
+function err(msg)  { const m = stripAnsi(msg); console.log(`${chalk.gray(ts())} ${chalk.red('✖')}  ${msg}`); if (currentBus) currentBus.emit('broadcast', 'log', { level: 'err', message: m, timestamp: ts() }); }
 function ts()      { return new Date().toISOString().replace('T', ' ').slice(0, 19); }
+function stripAnsi(s) { return s.replace(/\x1b\[[0-9;]*m/g, ''); }
 
 // ── Filename helpers ───────────────────────────────────────────────────────
 
@@ -69,6 +72,7 @@ async function resolveWatchList(config) {
                     knownEpisodes:   entry.totalEpisodes,
                     animeStatus:     entry.animeStatus,
                     anilistStatus:   entry.status,
+                    posterUrl:       entry.posterUrl || null,
                     nextAiringAt:    entry.nextAiring?.airingAt || null,
                 });
             }
@@ -90,6 +94,7 @@ async function resolveWatchList(config) {
             knownEpisodes:   null,
             animeStatus:     null,
             anilistStatus:   null,
+            posterUrl:       null,
             nextAiringAt:    null,
         });
     }
@@ -170,7 +175,7 @@ async function promptAnimeSelection(watchList) {
 
 // ── Per-anime download ─────────────────────────────────────────────────────
 
-async function processAnime(workItem, config, multiBar, auto = false, runQuality = null, runLanguage = null, range = null) {
+async function processAnime(workItem, config, multiBar, auto = false, runQuality = null, runLanguage = null, range = null, eventBus = null) {
     // Per-anime quality: run override > DB override > workItem > global config
     const dbAnimeRow = db.getAnimeBySiteTitle(workItem.title);
     const q = runQuality || dbAnimeRow?.override_quality || workItem.quality || config.quality || '1080p';
@@ -191,7 +196,8 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
         if (idMatch) {
             siteAnime = idMatch;
             info(`[${workItem.title}] Matched by AniList ID: ${chalk.bold(siteAnime.title)} (anilist:${siteAnime.anilistId})`);
-            db.saveConfirmedSiteMatch(workItem.title, siteAnime.session, siteAnime.title, siteAnime.poster || null);
+            const poster = workItem.posterUrl || siteAnime.poster || null;
+            db.saveConfirmedSiteMatch(workItem.title, siteAnime.session, siteAnime.title, poster);
         } else {
             warn(`[${workItem.title}] AniList ID ${workItem.anilistId} not found in search results — falling back to title match.`);
         }
@@ -326,7 +332,16 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
 
     info(`[${workItem.title}] ${toDownload.length} unwatched episode(s) to download (Q:${q} L:${l}, skipping first ${watched}).`);
 
-    const posterUrl = db.getAnimeBySiteTitle(workItem.title)?.poster_url || null;
+    if (eventBus) {
+      eventBus.emit('broadcast', 'anime:start', {
+        animeId: dbRow?.id,
+        title: workItem.title,
+        episodeCount: toDownload.length,
+        quality: q,
+      });
+    }
+
+    const posterUrl = workItem.posterUrl || null;
     await notify.notifyDownloadStart(cleanTitle, toDownload.length, q, posterUrl);
 
     const queue       = [...toDownload];
@@ -354,17 +369,26 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
             while (!success && attempts < MAX_RETRIES) {
                 attempts++;
                 try {
+                    if (eventBus) {
+                      eventBus.emit('broadcast', 'episode:start', {
+                        animeId: dbRow?.id,
+                        title: cleanTitle,
+                        episode: ep.episode,
+                        quality: q,
+                      });
+                    }
+
                     const links = await scraper.getDownloadLinks(siteAnime.session, ep.session, q);
                     const link  = scraper.pickLink(links, q, l);
                     if (!link?.mp4Url) throw new Error('No suitable download link found');
 
                     const relativeEp = epRelativeMap.get(ep.episode) || ep.episode;
                     const filename   = buildFilename(displayTitle, ep.episode, season, relativeEp);
-                    await scraper.downloadEpisode(link.mp4Url, filename, outputDir, multiBar, ep.episode);
+                    await scraper.downloadEpisode(link.mp4Url, filename, outputDir, multiBar, ep.episode, eventBus, dbRow?.id, cleanTitle);
 
                     db.markEpisodeStatus(dbRow.id, ep.episode, 'done', filename);
                     ok(`[${cleanTitle}] EP${ep.episode} → ${filename}`);
-                    const posterUrl = db.getAnimeBySiteTitle(workItem.title)?.poster_url || null;
+                    const posterUrl = workItem.posterUrl || null;
                     await notify.notifyEpisode(cleanTitle, relativeEp || ep.episode, q, posterUrl);
                     success = true;
                     results.downloaded++;
@@ -373,6 +397,15 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
                         err(`[${workItem.title}] EP${ep.episode} failed: ${e.message}`);
                         db.markEpisodeStatus(dbRow.id, ep.episode, 'failed', null, e.message);
                         await notify.notifyFailed(workItem.title, ep.episode, e.message);
+                        if (eventBus) {
+                          eventBus.emit('broadcast', 'episode:failed', {
+                            animeId: dbRow?.id,
+                            title: cleanTitle,
+                            episode: ep.episode,
+                            error: e.message,
+                            willRetry: false,
+                          });
+                        }
                         results.failed++;
                     } else {
                         warn(`[${workItem.title}] EP${ep.episode} attempt ${attempts} failed, retrying...`);
@@ -384,14 +417,24 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
     });
 
     await Promise.all(workers);
+
+    if (eventBus) {
+      eventBus.emit('broadcast', 'anime:complete', {
+        animeId: dbRow?.id,
+        title: workItem.title,
+        ...results,
+      });
+    }
+
     return results;
 }
 
 // ── Main cycle ─────────────────────────────────────────────────────────────
 
-async function runCycle({ auto = false, quality = null, language = null, range = null, statuses = null } = {}) {
+async function runCycle({ auto = false, quality = null, language = null, range = null, statuses = null, eventBus = null } = {}) {
     await db.initDb();
     const config = loadConfig();
+    currentBus = eventBus;
 
     console.log(chalk.bold.red('\n  ╔══════════════════════════════════╗'));
     console.log(chalk.bold.red(`  ║  ANI-AUTO v${version} — DOWNLOAD RUN  ║`));
@@ -402,9 +445,11 @@ async function runCycle({ auto = false, quality = null, language = null, range =
         : config;
     const watchList = await resolveWatchList(effectiveConfig);
 
-    if (!watchList.length) {
+        if (!watchList.length) {
         warn('Watch list is empty. Add entries via AniList or `ani-auto add`.');
         db.logRun({ downloaded: 0, skipped: 0, failed: 0, notes: 'empty watch list' });
+        if (eventBus) eventBus.emit('broadcast', 'run:complete', { downloaded: 0, skipped: 0, failed: 0 });
+        currentBus = null;
         return;
     }
 
@@ -416,6 +461,8 @@ async function runCycle({ auto = false, quality = null, language = null, range =
         selected = await promptAnimeSelection(watchList);
         if (!selected.length) {
             warn('No anime selected — exiting.');
+            if (eventBus) eventBus.emit('broadcast', 'run:complete', { downloaded: 0, skipped: 0, failed: 0 });
+            currentBus = null;
             return;
         }
     }
@@ -434,7 +481,7 @@ async function runCycle({ auto = false, quality = null, language = null, range =
     const totals = { downloaded: 0, skipped: 0, failed: 0 };
 
     for (const item of selected) {
-        const result = await processAnime(item, config, multiBar, auto, quality, language, range);
+        const result = await processAnime(item, config, multiBar, auto, quality, language, range, eventBus);
         totals.downloaded += result.downloaded;
         totals.skipped    += result.skipped;
         totals.failed     += result.failed;
@@ -450,8 +497,14 @@ async function runCycle({ auto = false, quality = null, language = null, range =
 
     db.logRun(totals);
     await notify.notifySummary(totals);
+
+    if (eventBus) {
+      eventBus.emit('broadcast', 'run:complete', totals);
+    }
+    currentBus = null;
+    return totals;
 }
 
 function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
 
-module.exports = { runCycle, resolveWatchList };
+module.exports = { runCycle, resolveWatchList, processAnime };

package/src/notify.js

@@ -3,10 +3,53 @@
 const { execSync } = require('child_process');
 const fetch = require('node-fetch');
 const { loadConfig } = require('./config');
-const { proxifyPosterUrl } = require('../utils');
 
 const BOT_TOKEN = '8695132702:AAEFDoSL6nkdwDOoz5wmoVkmuhaYa4tNw0o';
 
+async function fetchPosterBuffer(photoUrl) {
+    if (!photoUrl) return null;
+    const res = await fetch(photoUrl, { timeout: 10000 });
+    if (!res.ok) {
+        throw new Error(`Poster fetch failed: HTTP ${res.status}`);
+    }
+    const contentType = res.headers.get('content-type') || 'image/jpeg';
+    const buffer = await res.buffer();
+    if (!buffer || !buffer.length) {
+        throw new Error('Poster fetch returned empty body');
+    }
+    return { buffer, contentType };
+}
+
+function buildMultipartBody(fields, fileField) {
+    const boundary = `----ani-auto-${Date.now().toString(16)}`;
+    const chunks = [];
+
+    for (const [key, value] of Object.entries(fields)) {
+        chunks.push(Buffer.from(
+            `--${boundary}\r\n` +
+            `Content-Disposition: form-data; name="${key}"\r\n\r\n` +
+            `${value}\r\n`
+        ));
+    }
+
+    if (fileField) {
+        chunks.push(Buffer.from(
+            `--${boundary}\r\n` +
+            `Content-Disposition: form-data; name="${fileField.name}"; filename="${fileField.filename}"\r\n` +
+            `Content-Type: ${fileField.contentType}\r\n\r\n`
+        ));
+        chunks.push(fileField.buffer);
+        chunks.push(Buffer.from('\r\n'));
+    }
+
+    chunks.push(Buffer.from(`--${boundary}--\r\n`));
+
+    return {
+        body: Buffer.concat(chunks),
+        boundary,
+    };
+}
+
 async function sendTelegram(payload) {
     const config = loadConfig();
     const chatId = config.telegramChatId;
@@ -14,11 +57,44 @@ async function sendTelegram(payload) {
     try {
         const normalizedPayload = { ...payload };
         if (normalizedPayload.photo) {
-            normalizedPayload.photo = proxifyPosterUrl(normalizedPayload.photo);
+            const poster = await fetchPosterBuffer(normalizedPayload.photo);
+            const { body, boundary } = buildMultipartBody(
+                {
+                    chat_id: String(chatId),
+                    parse_mode: 'HTML',
+                    caption: normalizedPayload.caption || '',
+                },
+                {
+                    name: 'photo',
+                    filename: 'poster.jpg',
+                    contentType: poster.contentType,
+                    buffer: poster.buffer,
+                }
+            );
+            const res = await fetch(`https://api.telegram.org/bot${BOT_TOKEN}/sendPhoto`, {
+                method: 'POST',
+                headers: { 'Content-Type': `multipart/form-data; boundary=${boundary}` },
+                body,
+                timeout: 15000,
+            });
+            const text = await res.text();
+            if (!res.ok) {
+                throw new Error(`Telegram API ${res.status}: ${text.slice(0, 200)}`);
+            }
+            if (text) {
+                try {
+                    const data = JSON.parse(text);
+                    if (data.ok === false) {
+                        throw new Error(`Telegram API rejected message: ${data.description || 'unknown error'}`);
+                    }
+                } catch (err) {
+                    if (err.message.startsWith('Telegram API rejected message:')) throw err;
+                }
+            }
+            return;
         }
 
-        const endpoint = normalizedPayload.photo ? 'sendPhoto' : 'sendMessage';
-        const res = await fetch(`https://api.telegram.org/bot${BOT_TOKEN}/${endpoint}`, {
+        const res = await fetch(`https://api.telegram.org/bot${BOT_TOKEN}/sendMessage`, {
             method:  'POST',
             headers: { 'Content-Type': 'application/json' },
             body:    JSON.stringify({ chat_id: String(chatId), parse_mode: 'HTML', ...normalizedPayload }),
@@ -46,14 +122,13 @@ async function sendTelegram(payload) {
 async function sendDesktop(title, body, urgency = 'normal', posterUrl = null) {
     try {
         let icon = '';
-        const imageUrl = proxifyPosterUrl(posterUrl);
-        if (imageUrl) {
+        if (posterUrl) {
             const os    = require('os');
             const path  = require('path');
             const fs    = require('fs');
             const tmp   = path.join(os.tmpdir(), 'ani-auto-poster.jpg');
             try {
-                const res = await fetch(imageUrl);
+                const res = await fetch(posterUrl);
                 fs.writeFileSync(tmp, await res.buffer());
                 icon = `-i "${tmp}"`;
             } catch (e) {}

package/src/scraper.js

@@ -119,8 +119,8 @@ function pickLink(links, quality, language) {
     );
 }
 
-async function downloadEpisode(url, filename, outputDir, multiBar, episodeNum) {
-    await downloadFile(url, filename, outputDir, multiBar, episodeNum);
+async function downloadEpisode(url, filename, outputDir, multiBar, episodeNum, eventBus = null, animeId = null, animeTitle = null) {
+    await downloadFile(url, filename, outputDir, multiBar, episodeNum, eventBus, animeId, animeTitle);
 }
 
 module.exports = { searchAnime, searchAll, getEpisodes, getDownloadLinks, pickLink, downloadEpisode };

package/src/server.js

@@ -0,0 +1,108 @@
+'use strict';
+
+const express = require('express');
+const http = require('http');
+const path = require('path');
+const fs = require('fs');
+const { WebSocketServer } = require('ws');
+const cors = require('cors');
+
+const configRouter = require('./api/config');
+const anilistRouter = require('./api/anilist');
+const animeRouter = require('./api/anime');
+const matchRouter = require('./api/match');
+const downloadRouter = require('./api/download');
+const runsRouter = require('./api/runs');
+const daemonRouter = require('./api/daemon');
+const updateRouter = require('./api/update');
+
+const EventEmitter = require('events');
+const downloadBus = new EventEmitter();
+downloadBus.setMaxListeners(100);
+
+const PORT = process.env.PORT || 2640;
+const CLIENT_DIR = path.join(__dirname, '..', 'web', 'dist');
+
+const app = express();
+app.use(cors());
+app.use(express.json());
+
+app.use('/api/config', configRouter);
+app.use('/api/anilist', anilistRouter);
+app.use('/api/anime', animeRouter);
+app.use('/api/match', matchRouter);
+app.use('/api/runs', runsRouter);
+app.use('/api/daemon', daemonRouter);
+app.use('/api/download', downloadRouter(downloadBus));
+app.use('/api/update', updateRouter);
+
+const cfBypassRouter = require('./api/cf-bypass');
+app.use('/api', cfBypassRouter);
+
+const paheRouter = require('../anime/app');
+const PaheConfig = require('../anime/utils/config');
+const savedConfig = require('./config').loadConfig();
+if (savedConfig.animepaheCfClearance) {
+  PaheConfig.setCfClearance(savedConfig.animepaheCfClearance);
+}
+if (savedConfig.animepaheUserAgent) {
+  PaheConfig.userAgent = savedConfig.animepaheUserAgent;
+}
+app.use('/api/pahe', paheRouter);
+
+app.use(express.static(CLIENT_DIR));
+app.use((req, res) => {
+  if (req.path.startsWith('/api')) return res.status(404).json({ error: 'not found' });
+  res.sendFile(path.join(CLIENT_DIR, 'index.html'), (err) => {
+    if (err) res.status(404).json({ error: 'not found' });
+  });
+});
+
+const server = http.createServer(app);
+const wss = new WebSocketServer({ server, path: '/ws' });
+
+wss.on('connection', (ws) => {
+  ws.on('message', (data) => {
+    try {
+      const msg = JSON.parse(data);
+      if (msg.type === 'download:start') {
+        downloadBus.emit('ws:start', msg, ws);
+      }
+      if (msg.type === 'download:cancel') {
+        downloadBus.emit('ws:cancel');
+      }
+      if (msg.type === 'download:pause') {
+        downloadBus.emit('ws:pause');
+      }
+      if (msg.type === 'download:resume') {
+        downloadBus.emit('ws:resume');
+      }
+    } catch (e) {}
+  });
+});
+
+function broadcast(event, data) {
+  const payload = JSON.stringify({ type: event, ...data });
+  wss.clients.forEach((client) => {
+    if (client.readyState === 1) client.send(payload);
+  });
+}
+
+app.locals.broadcast = broadcast;
+
+downloadBus.on('broadcast', (event, data) => broadcast(event, data));
+
+function startServer() {
+  server.listen(PORT, () => {
+    console.log(`ani-auto web ui running at http://localhost:${PORT}`);
+  });
+}
+
+process.on('SIGINT', () => process.exit(0));
+process.on('SIGTERM', () => process.exit(0));
+
+module.exports = { startServer, downloadBus, broadcast, app };
+
+if (require.main === module) {
+  startServer();
+}