ani-auto 1.4.3 → 2.0.0

package/src/api/anime.js

@@ -0,0 +1,181 @@
+'use strict';
+
+const { Router } = require('express');
+const db = require('../db');
+const { loadConfig, updateConfig } = require('../config');
+const { searchAnime } = require('../anilist');
+
+const router = Router();
+
+async function init(req, res, next) {
+  await db.initDb();
+  next();
+}
+
+router.use(init);
+
+router.get('/', (req, res) => {
+  const rawDb = db.getDb();
+  const stmt = rawDb.prepare('SELECT * FROM anime ORDER BY title');
+  const all = [];
+  while (stmt.step()) all.push(stmt.getAsObject());
+  stmt.free();
+  const withStats = all.map((a) => ({
+    ...a,
+    stats: db.getEpisodeStats(a.id),
+  }));
+  res.json(withStats);
+});
+
+router.get('/:id', (req, res) => {
+  const rawDb = db.getDb();
+  const stmt = rawDb.prepare('SELECT * FROM anime WHERE id = ?');
+  stmt.bind([req.params.id]);
+  const row = stmt.step() ? stmt.getAsObject() : null;
+  stmt.free();
+  if (!row) return res.status(404).json({ error: 'not found' });
+  row.stats = db.getEpisodeStats(row.id);
+  res.json(row);
+});
+
+router.get('/:id/episodes', (req, res) => {
+  const episodes = db.getAllEpisodes(req.params.id);
+  res.json(episodes);
+});
+
+router.post('/', async (req, res) => {
+  try {
+    const { title, anilistId, quality, language, poster_url } = req.body;
+    if (!title) return res.status(400).json({ error: 'title required' });
+
+    let resolvedTitle = title;
+    let resolvedAnilistId = anilistId || null;
+
+    if (!anilistId) {
+      const results = await searchAnime(title);
+      if (results.length) {
+        resolvedAnilistId = results[0].anilistId;
+      }
+    }
+
+    const config = loadConfig();
+    const manualList = config.manualList || [];
+    const exists = manualList.find((m) => m.title.toLowerCase() === resolvedTitle.toLowerCase());
+    if (exists) {
+      return res.json({ ok: true, message: 'already in list' });
+    }
+
+    const entry = {
+      title: resolvedTitle,
+      anilistId: resolvedAnilistId,
+      enabled: true,
+      quality: quality || null,
+      language: language || null,
+      poster_url: poster_url || null,
+    };
+    manualList.push(entry);
+    updateConfig({ manualList });
+
+    db.upsertAnime({
+      title: resolvedTitle,
+      siteId: resolvedTitle,
+      anilistId: resolvedAnilistId,
+      source: 'manual',
+      quality: quality || null,
+      language: language || null,
+      poster_url: poster_url || null,
+    });
+
+    res.json({ ok: true, entry });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+router.delete('/:id', (req, res) => {
+  const rawDb = db.getDb();
+  const stmt = rawDb.prepare('SELECT * FROM anime WHERE id = ?');
+  stmt.bind([req.params.id]);
+  const row = stmt.step() ? stmt.getAsObject() : null;
+  stmt.free();
+  if (!row) return res.status(404).json({ error: 'not found' });
+
+  db.removeAnime(row.site_id);
+
+  const config = loadConfig();
+  const manualList = (config.manualList || []).filter(
+    (m) => m.title.toLowerCase() !== (row.anilist_title || row.title).toLowerCase()
+  );
+  updateConfig({ manualList });
+
+  res.json({ ok: true });
+});
+
+router.put('/:id/enable', (req, res) => {
+  const enabled = req.body.enabled !== false;
+  const rawDb = db.getDb();
+  const stmt = rawDb.prepare('SELECT * FROM anime WHERE id = ?');
+  stmt.bind([req.params.id]);
+  const row = stmt.step() ? stmt.getAsObject() : null;
+  stmt.free();
+  if (!row) return res.status(404).json({ error: 'not found' });
+  db.setAnimeEnabled(row.site_id, enabled);
+  res.json({ ok: true, enabled });
+});
+
+router.put('/:id/quality', (req, res) => {
+  const quality = req.body.quality || null;
+  const rawDb = db.getDb();
+  const stmt = rawDb.prepare('SELECT * FROM anime WHERE id = ?');
+  stmt.bind([req.params.id]);
+  const row = stmt.step() ? stmt.getAsObject() : null;
+  stmt.free();
+  if (!row) return res.status(404).json({ error: 'not found' });
+  db.setAnimeQuality(row.anilist_title || row.title, quality);
+  res.json({ ok: true, quality });
+});
+
+router.put('/:id/language', (req, res) => {
+  const language = req.body.language || null;
+  const rawDb = db.getDb();
+  const stmt = rawDb.prepare('SELECT * FROM anime WHERE id = ?');
+  stmt.bind([req.params.id]);
+  const row = stmt.step() ? stmt.getAsObject() : null;
+  stmt.free();
+  if (!row) return res.status(404).json({ error: 'not found' });
+  db.setAnimeQuality(row.anilist_title || row.title, language);
+  res.json({ ok: true, language });
+});
+
+router.post('/refresh-posters', async (req, res) => {
+  try {
+    await db.initDb();
+    const rawDb = db.getDb();
+    const stmt = rawDb.prepare("SELECT * FROM anime WHERE poster_url IS NULL AND anilist_id IS NOT NULL");
+    const rows = [];
+    while (stmt.step()) rows.push(stmt.getAsObject());
+    stmt.free();
+    const { getMediaById } = require('../anilist');
+    const config = loadConfig();
+    let updated = 0;
+    for (const row of rows) {
+      try {
+        const media = await getMediaById(row.anilist_id, config.anilistToken || null);
+        if (media?.coverImage) {
+          const url = media.coverImage.extraLarge || media.coverImage.large || media.coverImage.medium;
+          if (url) {
+            db.execSql('UPDATE anime SET poster_url = ? WHERE id = ?', [url, row.id]);
+            updated++;
+          }
+        }
+      } catch (e) {
+        console.warn('failed to fetch poster for', row.anilist_id, e.message);
+      }
+    }
+    res.json({ ok: true, updated, total: rows.length });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+module.exports = router;

package/src/api/cf-bypass.js

@@ -0,0 +1,131 @@
+'use strict';
+
+const { Router } = require('express');
+const { loadConfig, updateConfig } = require('../config');
+const { execSync, spawnSync } = require('child_process');
+const path = require('path');
+
+const router = Router();
+
+const BYPASS_URL = 'https://animepahe.pw';
+const COOKIE_READER = path.join(__dirname, '..', '..', 'cookiereader.py');
+
+function runCookiereader(...args) {
+  try {
+    const stdout = execSync(`python3 "${COOKIE_READER}" ${args.join(' ')}`, {
+      encoding: 'utf8',
+      timeout: 15000,
+      stdio: ['pipe', 'pipe', 'ignore'],
+    });
+    return JSON.parse(stdout.trim());
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+
+function verifyWithCurl(cfClearance, userAgent) {
+  try {
+    const testUrl = 'https://animepahe.pw/api?m=search&q=Naruto&page=1';
+    const args = ['-sS', '-L', '--compressed'];
+    args.push('-b', `cf_clearance=${cfClearance}`);
+    if (userAgent) args.push('-A', userAgent);
+    args.push('-w', '\n%{http_code}');
+    args.push(testUrl);
+
+    const result = spawnSync('curl', args, { encoding: 'utf8', timeout: 15000 });
+    if (result.error) throw result.error;
+    const lines = result.stdout.trim().split('\n');
+    const statusCode = parseInt(lines.pop(), 10);
+    const body = lines.join('\n');
+
+    if (statusCode === 403 || body.includes('Just a moment') || body.includes('DDoS-GUARD')) {
+      return { ok: false, error: 'Cookies rejected by Cloudflare' };
+    }
+    if (statusCode !== 200) {
+      return { ok: false, error: `Unexpected HTTP ${statusCode}` };
+    }
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+router.post('/cf-bypass/detect', async (req, res) => {
+  const result = runCookiereader('detect');
+  if (result.error) {
+    return res.status(500).json({ ok: false, error: result.error });
+  }
+
+  const found = {};
+  for (const [browser, data] of Object.entries(result)) {
+    if (data.found) {
+      found[browser] = {
+        found: true,
+        cookie_string: data.cookie_string,
+      };
+    } else if (data.error) {
+      found[browser] = { found: false, error: data.error };
+    }
+  }
+
+  res.json({ ok: true, browsers: result, found });
+});
+
+router.post('/cf-bypass/save', async (req, res) => {
+  const { cfClearance, userAgent } = req.body || {};
+  if (!cfClearance) {
+    return res.status(400).json({ ok: false, error: 'cf_clearance value is required' });
+  }
+
+  const ua = userAgent || 'Mozilla/5.0 (X11; Linux x86_64; rv:144.0) Gecko/20100101 Firefox/144.0';
+
+  const verifyResult = verifyWithCurl(cfClearance, ua);
+  if (!verifyResult.ok) {
+    return res.status(400).json({
+      ok: false,
+      error: verifyResult.error || 'Verification failed',
+    });
+  }
+
+  updateConfig({
+    animepaheCfClearance: cfClearance,
+    animepaheUserAgent: ua,
+  });
+
+  try {
+    const PaheConfig = require('../../anime/utils/config');
+    PaheConfig.setCfClearance(cfClearance);
+    PaheConfig.userAgent = ua;
+  } catch (e) {
+    console.warn('[cf-bypass] Could not update PaheConfig:', e.message);
+  }
+
+  console.log(`[cf-bypass] cf_clearance saved and verified`);
+  res.json({ ok: true, message: 'Saved and verified' });
+});
+
+router.get('/cf-bypass/status', (req, res) => {
+  const config = loadConfig();
+  res.json({
+    bypassed: !!config.animepaheCfClearance,
+    userAgent: config.animepaheUserAgent || null,
+  });
+});
+
+router.delete('/cf-bypass', (req, res) => {
+  updateConfig({
+    animepaheCfClearance: null,
+    animepaheUserAgent: null,
+  });
+
+  try {
+    const PaheConfig = require('../../anime/utils/config');
+    PaheConfig.setCfClearance('');
+  } catch (e) {
+    console.warn('[cf-bypass] Could not clear PaheConfig:', e.message);
+  }
+
+  res.json({ ok: true });
+});
+
+module.exports = router;

package/src/api/config.js

@@ -0,0 +1,134 @@
+'use strict';
+
+const { Router } = require('express');
+const fetch = require('node-fetch');
+const { loadConfig, updateConfig } = require('../config');
+const { getViewer } = require('../anilist');
+
+const router = Router();
+
+router.get('/', async (req, res) => {
+  const config = { ...loadConfig() };
+  if (config.anilistToken) {
+    if (!config.anilistAvatar) {
+      try {
+        const viewer = await getViewer(config.anilistToken);
+        if (viewer?.avatar?.medium) {
+          config.anilistAvatar = viewer.avatar.medium;
+          updateConfig({ anilistAvatar: viewer.avatar.medium });
+        }
+      } catch (e) { console.warn('failed to fetch anilist avatar', e); }
+    }
+    config.anilistToken = '[set]';
+  }
+  if (config.anilistClientSecret) config.anilistClientSecret = '[set]';
+  if (config.animepaheCfClearance) config.animepaheCfClearance = '[set]';
+  if (config.animepaheUserAgent) config.animepaheUserAgent = '[set]';
+  res.json(config);
+});
+
+router.put('/', (req, res) => {
+  const updates = {};
+  const allowed = [
+    'anilistUsername', 'anilistToken', 'anilistAvatar', 'watchStatuses',
+    'quality', 'language', 'concurrency', 'outputDir', 'maxRetries',
+    'daemonIntervalMinutes', 'airingBufferMinutes', 'daemonEnabled',
+    'autoUpdateCheck',
+    'telegramChatId', 'telegramNotify',
+    'manualList', 'onboardingSkipped',
+    'anilistClientId', 'anilistClientSecret',
+  ];
+  for (const key of allowed) {
+    if (req.body[key] !== undefined) updates[key] = req.body[key];
+  }
+  const updated = updateConfig(updates);
+  if (updated.anilistToken) updated.anilistToken = '[set]';
+  if (updated.anilistClientSecret) updated.anilistClientSecret = '[set]';
+  if (updated.animepaheCfClearance) updated.animepaheCfClearance = '[set]';
+  if (updated.animepaheUserAgent) updated.animepaheUserAgent = '[set]';
+  res.json(updated);
+});
+
+router.get('/oauth-url', (req, res) => {
+  const config = loadConfig();
+  const hasSecret = !!config.anilistClientSecret;
+
+  if (hasSecret) {
+    const base = req.protocol + '://' + req.get('host');
+    const callbackUrl = base + '/api/config/oauth-callback';
+    const url = 'https://anilist.co/api/v2/oauth/authorize'
+      + '?client_id=' + config.anilistClientId
+      + '&redirect_uri=' + encodeURIComponent(callbackUrl)
+      + '&response_type=code';
+    res.json({ url });
+  } else {
+    res.json({
+      url: 'https://anilist.co/api/v2/oauth/authorize?client_id=37183&response_type=token',
+    });
+  }
+});
+
+router.get('/oauth-callback', async (req, res) => {
+  const code = req.query.code;
+  if (!code) {
+    return res.type('html').send(`<!DOCTYPE html>
+<html><head><meta charset="utf-8"><title>Redirect...</title></head>
+<body><script>window.location.replace('/oauth/callback'+window.location.hash)</script></body></html>`);
+  }
+
+  const config = loadConfig();
+  const clientId = config.anilistClientId || '37183';
+  const clientSecret = config.anilistClientSecret;
+  if (!clientSecret) {
+    return res.status(400).send('No AniList client secret configured');
+  }
+
+  const base = req.protocol + '://' + req.get('host');
+  const callbackUrl = base + '/api/config/oauth-callback';
+
+  try {
+    const tokenRes = await fetch('https://anilist.co/api/v2/oauth/token', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
+      body: JSON.stringify({
+        grant_type: 'authorization_code',
+        client_id: clientId,
+        client_secret: clientSecret,
+        redirect_uri: callbackUrl,
+        code,
+      }),
+    });
+
+    if (!tokenRes.ok) {
+      const text = await tokenRes.text();
+      console.error('token exchange failed', tokenRes.status, text);
+      return res.redirect(base + '/oauth/callback#error=token_exchange_failed');
+    }
+
+    const tokenData = await tokenRes.json();
+    const token = tokenData.access_token;
+
+    const viewer = await getViewer(token);
+    updateConfig({
+      anilistToken: token,
+      anilistUsername: viewer.name,
+      anilistAvatar: viewer.avatar?.medium || null,
+    });
+
+    res.redirect(base + '/oauth/callback#access_token=' + encodeURIComponent(token));
+  } catch (e) {
+    console.error('oauth callback error', e);
+    res.redirect(base + '/oauth/callback#error=' + encodeURIComponent(e.message));
+  }
+});
+
+router.post('/verify-token', async (req, res) => {
+  try {
+    const viewer = await getViewer(req.body.token);
+    res.json({ ok: true, name: viewer.name, avatar: viewer.avatar?.medium || null });
+  } catch (e) {
+    res.json({ ok: false, error: e.message });
+  }
+});
+
+module.exports = router;

package/src/api/daemon.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const { Router } = require('express');
+const { spawnSync, spawn } = require('child_process');
+const { loadConfig, updateConfig } = require('../config');
+
+const router = Router();
+const SERVICE = 'ani-auto';
+
+function run(cmd) {
+  try {
+    const r = spawnSync(cmd, { shell: true, encoding: 'utf8', timeout: 10000 });
+    return { out: r.stdout?.trim(), err: r.stderr?.trim(), code: r.status };
+  } catch (e) {
+    return { out: '', err: e.message, code: 1 };
+  }
+}
+
+router.get('/status', (req, res) => {
+  const config = loadConfig();
+  const enabled = config.daemonEnabled !== false;
+  const r = run(`systemctl --user status ${SERVICE}`);
+  const running = r.out?.includes('active (running)');
+  res.json({ enabled, running, output: r.out || r.err });
+});
+
+router.post('/start', (req, res) => {
+  const config = loadConfig();
+  if (config.daemonEnabled === false) {
+    return res.json({ ok: false, error: 'daemon is disabled' });
+  }
+  const r = run(`systemctl --user start ${SERVICE}`);
+  res.json({ ok: r.code === 0, error: r.err || null });
+});
+
+router.post('/stop', (req, res) => {
+  const r = run(`systemctl --user stop ${SERVICE}`);
+  res.json({ ok: r.code === 0, error: r.err || null });
+});
+
+router.post('/restart', (req, res) => {
+  const config = loadConfig();
+  if (config.daemonEnabled === false) {
+    return res.json({ ok: false, error: 'daemon is disabled' });
+  }
+  const r = run(`systemctl --user restart ${SERVICE}`);
+  res.json({ ok: r.code === 0, error: r.err || null });
+});
+
+router.post('/enable', (req, res) => {
+  updateConfig({ daemonEnabled: true });
+  run(`systemctl --user start ${SERVICE}`);
+  res.json({ ok: true });
+});
+
+router.post('/disable', (req, res) => {
+  updateConfig({ daemonEnabled: false });
+  run(`systemctl --user stop ${SERVICE}`);
+  res.json({ ok: true });
+});
+
+module.exports = router;

package/src/api/download.js

@@ -0,0 +1,98 @@
+'use strict';
+
+const { Router } = require('express');
+const { loadConfig } = require('../config');
+const db = require('../db');
+const { runCycle } = require('../engine');
+const scraper = require('../scraper');
+const { EventEmitter } = require('events');
+
+module.exports = function createDownloadRouter(downloadBus) {
+  const router = Router();
+
+  router.post('/run', async (req, res) => {
+    try {
+      const quality = req.body.quality || null;
+      const language = req.body.language || null;
+      const statuses = req.body.statuses || null;
+      runCycle({ auto: true, quality, language, statuses, eventBus: downloadBus })
+        .catch((e) => {
+          downloadBus.emit('broadcast', 'run:error', { error: e.message });
+        });
+      res.json({ ok: true, message: 'Download cycle started' });
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  router.post('/anime/:id', async (req, res) => {
+    try {
+      await db.initDb();
+      const config = loadConfig();
+      const rawDb = db.getDb();
+      const stmt = rawDb.prepare('SELECT * FROM anime WHERE id = ?');
+      stmt.bind([req.params.id]);
+      const row = stmt.step() ? stmt.getAsObject() : null;
+      stmt.free();
+      if (!row) return res.status(404).json({ error: 'anime not found' });
+
+      const watchItem = {
+        title: row.anilist_title || row.title,
+        anilistId: row.anilist_id,
+        source: row.source,
+        quality: row.override_quality || row.quality || null,
+        language: row.language || null,
+        watchedEpisodes: 0,
+        knownEpisodes: null,
+        posterUrl: row.poster_url || null,
+      };
+
+      const { processAnime } = require('../engine');
+      processAnime(watchItem, config, null, true, req.body.quality || null, req.body.language || null, null, downloadBus)
+        .then((result) => {
+          downloadBus.emit('broadcast', 'anime:complete', { animeId: req.params.id, ...result });
+          downloadBus.emit('broadcast', 'run:complete', { downloaded: result?.downloaded || 0, skipped: result?.skipped || 0, failed: result?.failed || 0 });
+        })
+        .catch((e) => {
+          downloadBus.emit('broadcast', 'anime:error', { animeId: req.params.id, error: e.message });
+        });
+
+      res.json({ ok: true, message: `Download started for ${watchItem.title}` });
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  router.post('/retry', async (req, res) => {
+    try {
+      await db.initDb();
+      const failed = db.getFailedEpisodes();
+      if (!failed.length) return res.json({ ok: true, message: 'no failed episodes' });
+
+      const byAnime = {};
+      for (const ep of failed) {
+        const key = ep.anilist_title || ep.title;
+        if (!byAnime[key]) byAnime[key] = [];
+        byAnime[key].push(ep);
+      }
+
+      for (const [title, eps] of Object.entries(byAnime)) {
+        for (const ep of eps) {
+          db.markEpisodeStatus(ep.anime_id, ep.episode_num, 'pending', null, null);
+        }
+      }
+
+      const config = loadConfig();
+      runCycle({ auto: true, quality: null, language: null, statuses: null, eventBus: downloadBus })
+        .catch((e) => {
+          downloadBus.emit('broadcast', 'run:error', { error: e.message });
+        });
+
+      res.json({ ok: true, message: `Retrying ${failed.length} failed episode(s)` });
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  return router;
+};

package/src/api/match.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const { Router } = require('express');
+const db = require('../db');
+const scraper = require('../scraper');
+
+const router = Router();
+
+router.get('/search', async (req, res) => {
+  try {
+    const q = req.query.q;
+    const anilistId = req.query.anilistId || null;
+    if (!q) return res.status(400).json({ error: 'query required' });
+    const results = await scraper.searchAll(q);
+    const data = results.map((r) => ({
+      session: r.session,
+      title: r.title,
+      year: r.year,
+      episodes: r.episodes,
+      poster: r.poster,
+      anilistId: r.anilistId,
+    }));
+    let autoMatch = null;
+    if (anilistId) {
+      autoMatch = data.find((r) => r.anilistId === String(anilistId)) || null;
+    }
+    res.json({ results: data, autoMatch });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+router.post('/confirm', async (req, res) => {
+  try {
+    const { anilistTitle, session, title, anilistId } = req.body;
+    if (!anilistTitle || !session) {
+      return res.status(400).json({ error: 'anilistTitle and session required' });
+    }
+    await db.initDb();
+    let finalPoster = null;
+    const { getMediaById } = require('../anilist');
+    const id = anilistId || (db.getAnimeBySiteTitle(anilistTitle)?.anilist_id);
+    if (id) {
+      try {
+        const media = await getMediaById(id);
+        if (media?.coverImage) {
+          finalPoster = media.coverImage.extraLarge || media.coverImage.large || media.coverImage.medium;
+        }
+      } catch {}
+    }
+    db.saveConfirmedSiteMatch(anilistTitle, session, title || session, finalPoster);
+    res.json({ ok: true });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+module.exports = router;

package/src/api/runs.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const { Router } = require('express');
+const db = require('../db');
+
+const router = Router();
+
+router.get('/', async (req, res) => {
+  await db.initDb();
+  const limit = parseInt(req.query.limit) || 10;
+  const runs = db.getRecentRuns(limit);
+  res.json(runs);
+});
+
+module.exports = router;