ani-auto 1.4.4 → 2.0.0

package/anime/utils/urlConverter.js

@@ -0,0 +1,88 @@
+const path = require('path');
+
+class UrlConverter {
+    /**
+     * Converts a stream m3u8 URL to a direct MP4 download URL
+     * Input: https://exampledomain.top/stream/14/04/{hash}/uwu.m3u8
+     * Output: https://anotherexampledomain.cx/mp4/14/04/{hash}
+     * 
+     * @param {string} m3u8Url - The original stream URL   
+     * @param {string} kwikDomain - The kwik domain (e.g. 'kwik.cx')
+     * @returns {string|null} - The converted download URL or null if invalid
+     */
+    static getMp4Url(m3u8Url, kwikDomain) {
+        if (!m3u8Url || !m3u8Url.includes('/stream/')) return null;
+        
+        try {
+            const urlObj = new URL(m3u8Url);
+
+            // Preserve the exact CDN host returned by AnimePahe.
+            // The site has been switching between hosts like uwucdn.top and
+            // owocdn.top, so forcing Config.iframeBaseUrl can produce bad links.
+            urlObj.pathname = urlObj.pathname.replace('/stream/', '/mp4/');
+            
+            if (urlObj.pathname.endsWith('/uwu.m3u8')) {
+                urlObj.pathname = urlObj.pathname.replace('/uwu.m3u8', '');
+            } else if (urlObj.pathname.endsWith('.m3u8')) {
+                urlObj.pathname = urlObj.pathname.replace('.m3u8', '');
+            }
+            
+            return urlObj.toString();
+        } catch (e) {
+            console.error('Error converting stream URL:', e);
+            return null;
+        }
+    }
+
+    /**
+     * Generates a descriptive filename for the download
+     * Format: AnimePahe_{Anime_Title}_{Eng_Dub?}_-_{Episode}_{BD?}_{Resolution}_{Fansub}.mp4
+     */
+    static getFilename(animeTitle, episode, resolution, fansub, isDub, isBD) {
+        if (!animeTitle) return 'video.mp4';
+        
+        // Sanitize title
+        const safeTitle = animeTitle.replace(/[^a-z0-9]/gi, '_').replace(/_+/g, '_');
+        const dubStr = isDub ? '_Eng_Dub' : '';
+        const bdStr = isBD ? '_BD' : '';
+        const resStr = resolution ? `_${resolution}p` : '';
+        const fansubStr = fansub ? `_${fansub}` : '';
+        const epStr = episode || '0';
+        
+        return `AnimePahe_${safeTitle}${dubStr}_-_${epStr}${bdStr}${resStr}${fansubStr}.mp4`;
+    }
+
+    /**
+     * Builds the full download URL with filename parameter and CDN headers
+     * Returns an object with url and headers for proper CDN access
+     * 
+     * @returns {Object} { url, headers } where headers contains Referer
+     */
+    static buildDownloadUrl(m3u8Url, kwikDomain, metadata) {
+        const mp4Url = this.getMp4Url(m3u8Url, kwikDomain);
+        if (!mp4Url) return null;
+        
+        const filename = this.getFilename(
+            metadata.animeTitle,
+            metadata.episode,
+            metadata.resolution,
+            metadata.fansub,
+            metadata.isDub,
+            metadata.isBD
+        );
+        
+        const downloadUrl = `${mp4Url}?file=${filename}`;
+        
+        const headers = {
+            Referer: 'https://kwik.cx/',
+            Origin: 'https://kwik.cx',
+        };
+        
+        return {
+            url: downloadUrl,
+            headers,
+        };
+    }
+}
+
+module.exports = UrlConverter;

package/anime/utils/webhookNotifier.js

@@ -0,0 +1,190 @@
+const fs = require("fs").promises;
+const path = require("path");
+const axios = require("axios");
+const HomeModel = require("../models/homeModel");
+const PlayModel = require("../models/playModel");
+
+const STATE_PATH = process.env.WEBHOOK_STATE_PATH || path.join("/tmp", "anime-webhook-state.json");
+const POLL_MS = Math.max(parseInt(process.env.WEBHOOK_POLL_MS || "600000", 10), 60000);
+const DOWNLOAD_PROXY_BASE = String(process.env.DOWNLOAD_PROXY_BASE || "").trim().replace(/\/+$/, "");
+
+let interval = null;
+let running = false;
+let sentState = new Set();
+let loaded = false;
+
+function isEnabled() {
+  return !!(process.env.WEBHOOK_URL && process.env.WEBHOOK_SECRET);
+}
+
+function buildKey(item) {
+  return [
+    item.anime_session || "",
+    item.episode_session || "",
+    item.episode || "",
+  ].join(":");
+}
+
+function buildProxyUrl(url) {
+  if (!url) return url;
+  if (!DOWNLOAD_PROXY_BASE) return url;
+  return `${DOWNLOAD_PROXY_BASE}/api/anime/download-proxy?url=${encodeURIComponent(url)}`;
+}
+
+async function loadState() {
+  if (loaded) return;
+  loaded = true;
+  try {
+    const raw = await fs.readFile(STATE_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed.sent)) {
+      sentState = new Set(parsed.sent);
+    }
+  } catch (_) {
+    sentState = new Set();
+  }
+}
+
+async function saveState() {
+  try {
+    const payload = JSON.stringify({ sent: Array.from(sentState).slice(-1000) });
+    await fs.writeFile(STATE_PATH, payload, "utf8");
+  } catch (err) {
+    console.error("[webhook] state save failed:", err.message);
+  }
+}
+
+async function postWebhook(payload) {
+  const res = await axios.post(process.env.WEBHOOK_URL, payload, {
+    timeout: 15000,
+    headers: {
+      "Content-Type": "application/json",
+      "x-webhook-secret": process.env.WEBHOOK_SECRET,
+    },
+    validateStatus: () => true,
+  });
+
+  if (res.status < 200 || res.status >= 300) {
+    throw new Error(`webhook HTTP ${res.status}: ${JSON.stringify(res.data).slice(0, 200)}`);
+  }
+
+  return res.data;
+}
+
+async function buildPayload(item) {
+  if (!item.anime_session || !item.episode_session) return null;
+
+  const detail = await PlayModel.getStreamingLinks(item.anime_session, item.episode_session, true);
+  const downloads = Array.isArray(detail?.downloads) ? detail.downloads : [];
+  const usable = downloads
+    .map((dl) => ({
+      quality: dl.quality || dl.resolution || null,
+      filesize: dl.filesize || dl.size || null,
+      isDub: Boolean(dl.isDub || dl.dub),
+      url: buildProxyUrl(dl.download || dl.url || null),
+    }))
+    .filter((dl) => dl.url);
+
+  if (!usable.length) return null;
+
+  return {
+    anime_id: item.anime_id || null,
+    anime_session: item.anime_session || null,
+    episode: item.episode || null,
+    episode_session: item.episode_session || null,
+    title: detail?.anime_title || item.title || null,
+    image: item.image || null,
+    created_at: item.created_at || null,
+    downloads: usable,
+  };
+}
+
+async function tick() {
+  return runTick({});
+}
+
+async function runTick(options = {}) {
+  if (running || !isEnabled()) return;
+  running = true;
+  let seen = 0;
+  let delivered = 0;
+  let missingEpisodeSession = 0;
+  let alreadySent = 0;
+  let unresolvedDownloads = 0;
+  let matchedTarget = 0;
+
+  try {
+    await loadState();
+    const airing = await HomeModel.getAiringAnime(1);
+    const items = Array.isArray(airing?.data) ? airing.data : [];
+    const targetSession = String(options.animeSession || "").trim() || null;
+
+    for (const item of items) {
+      if (targetSession && String(item.anime_session || "") !== targetSession) continue;
+      matchedTarget += 1;
+      const key = buildKey(item);
+      if (!item.episode_session) {
+        missingEpisodeSession += 1;
+        console.warn(`[webhook] skip missing episode_session: ${item.anime_session || "unknown"} ep=${item.episode || "?"}`);
+        continue;
+      }
+      seen += 1;
+      if (sentState.has(key)) {
+        alreadySent += 1;
+        continue;
+      }
+
+      try {
+        const payload = await buildPayload(item);
+        if (!payload) {
+          unresolvedDownloads += 1;
+          console.warn(`[webhook] skip unresolved downloads: ${item.title || item.anime_title || item.anime_session}`);
+          continue;
+        }
+
+        const result = await postWebhook(payload);
+        console.log(`[webhook] delivered ${key} matched=${result?.matched ?? "?"} delivered=${result?.delivered ?? "?"}`);
+        sentState.add(key);
+        delivered += Number(result?.delivered || 0);
+        if (sentState.size > 1000) {
+          sentState = new Set(Array.from(sentState).slice(-1000));
+        }
+        await saveState();
+      } catch (err) {
+        console.error(`[webhook] failed ${key}:`, err.message);
+      }
+    }
+  } catch (err) {
+    console.error("[webhook] tick failed:", err.message);
+    throw err;
+  } finally {
+    running = false;
+  }
+
+  return {
+    matchedTarget,
+    seen,
+    delivered,
+    missingEpisodeSession,
+    alreadySent,
+    unresolvedDownloads,
+  };
+}
+
+function startWebhookNotifier() {
+  if (!isEnabled()) {
+    console.log("[webhook] disabled (set WEBHOOK_URL and WEBHOOK_SECRET to enable)");
+    return;
+  }
+  if (interval) return;
+  console.log(`[webhook] enabled -> ${process.env.WEBHOOK_URL}`);
+  tick().catch(() => {});
+  interval = setInterval(() => {
+    tick().catch(() => {});
+  }, POLL_MS);
+}
+
+module.exports = {
+  startWebhookNotifier,
+  runTick,
+};

package/cookiereader.py

@@ -0,0 +1,291 @@
+#!/usr/bin/env python3
+"""Multi-browser AnimePahe cookie reader.
+
+Commands:
+  detect   Scan all browsers for animepahe cookies
+  read     Read cookies from a specific browser
+  clear    Delete animepahe cookies from a specific browser
+
+Output is JSON to stdout.
+"""
+import argparse
+import json
+import os
+import shutil
+import sqlite3
+import sys
+import tempfile
+
+# ── Browser cookie locations ──────────────────────────────────────────
+FIREFOX_DIRS = [os.path.expanduser("~/.mozilla/firefox")]
+CHROMIUM_BASED = [
+    ("chrome", os.path.expanduser("~/.config/google-chrome")),
+    ("chromium", os.path.expanduser("~/.config/chromium")),
+    ("brave", os.path.expanduser("~/.config/BraveSoftware/Brave-Browser")),
+    ("edge", os.path.expanduser("~/.config/microsoft-edge")),
+]
+
+DOMAIN_FILTERS = ["%animepahe%", "%pahe%"]
+
+# ── Helpers ───────────────────────────────────────────────────────────
+
+def _find_firefox_profiles():
+    profiles = []
+    for d in FIREFOX_DIRS:
+        if not os.path.isdir(d):
+            continue
+        for entry in os.listdir(d):
+            db_path = os.path.join(d, entry, "cookies.sqlite")
+            if os.path.isfile(db_path):
+                profiles.append({"profile": entry, "path": db_path})
+    return profiles
+
+
+def _read_firefox_cookies(db_path):
+    tmp = tempfile.mktemp(suffix=".sqlite")
+    try:
+        shutil.copy2(db_path, tmp)
+        wal = db_path + "-wal"
+        if os.path.isfile(wal):
+            shutil.copy2(wal, tmp + "-wal")
+        conn = sqlite3.connect(tmp)
+        cursor = conn.cursor()
+        cursor.execute(
+            "SELECT name, value FROM moz_cookies WHERE host LIKE ? OR host LIKE ?",
+            DOMAIN_FILTERS,
+        )
+        rows = cursor.fetchall()
+        conn.close()
+        return {name: val for name, val in rows}
+    except Exception as e:
+        return {"_error": str(e)}
+    finally:
+        try: os.unlink(tmp)
+        except: pass
+        try: os.unlink(tmp + "-wal")
+        except: pass
+
+
+def _find_chromium_profiles(browser_name, base_dir):
+    profiles = []
+    if not os.path.isdir(base_dir):
+        return profiles
+    for entry in os.listdir(base_dir):
+        cookie_path = os.path.join(base_dir, entry, "Cookies")
+        local_state = os.path.join(base_dir, "Local State")
+        if os.path.isfile(cookie_path):
+            profiles.append({
+                "profile": entry,
+                "path": cookie_path,
+                "local_state": local_state if os.path.isfile(local_state) else None,
+            })
+    return profiles
+
+
+def _decrypt_chromium_cookies(browser_name, profile):
+    """Attempt to decrypt cookies from a Chromium-based browser.
+    
+    Returns dict of cookie name→value, or dict with _error key.
+    Returns empty dict on failure — caller should fall back gracefully.
+    """
+    # For now, this is a best-effort attempt that may fail on modern
+    # setups (portal-based encryption on KDE, etc.)
+    return {}
+
+
+def _read_chromium_cookies(browser_name, profile):
+    tmp = tempfile.mktemp(suffix=".sqlite")
+    try:
+        shutil.copy2(profile["path"], tmp)
+        conn = sqlite3.connect(tmp)
+        cursor = conn.cursor()
+        cursor.execute(
+            "SELECT name, value, encrypted_value FROM cookies "
+            "WHERE host_key LIKE ? OR host_key LIKE ?",
+            DOMAIN_FILTERS,
+        )
+        rows = cursor.fetchall()
+        conn.close()
+
+        cookies = {}
+        for name, value, enc_val in rows:
+            if value:
+                cookies[name] = value
+            else:
+                if enc_val and enc_val[:3] in (b"v10", b"v11"):
+                    try_decrypt = _decrypt_chromium_cookies(browser_name, profile)
+                    if name in try_decrypt:
+                        cookies[name] = try_decrypt[name]
+        return cookies
+    except Exception as e:
+        return {"_error": str(e)}
+    finally:
+        try: os.unlink(tmp)
+        except: pass
+
+
+def _cookie_map_to_string(cookies):
+    parts = []
+    for k, v in cookies.items():
+        if k.startswith("_"):
+            continue
+        parts.append(f"{k}={v}")
+    return "; ".join(parts)
+
+
+# ── Commands ──────────────────────────────────────────────────────────
+
+def cmd_detect():
+    result = {}
+
+    # Firefox
+    ff_profiles = _find_firefox_profiles()
+    ff_cookies = {}
+    for p in ff_profiles:
+        c = _read_firefox_cookies(p["path"])
+        if "_error" not in c and c:
+            ff_cookies.update(c)
+    if ff_cookies:
+        result["firefox"] = {
+            "found": True,
+            "profiles": [p["profile"] for p in ff_profiles],
+            "cookies": {k: v for k, v in ff_cookies.items() if not k.startswith("_")},
+            "cookie_string": _cookie_map_to_string(ff_cookies),
+        }
+    else:
+        result["firefox"] = {"found": False, "profiles": [p["profile"] for p in ff_profiles]}
+
+    # Chromium-based
+    for name, base_dir in CHROMIUM_BASED:
+        profiles = _find_chromium_profiles(name, base_dir)
+        if not profiles:
+            result[name] = {"found": False, "error": "No profiles found"}
+            continue
+        all_cookies = {}
+        for p in profiles:
+            c = _read_chromium_cookies(name, p)
+            if "_error" not in c and c:
+                all_cookies.update(c)
+        encrypted = any(p["path"] for p in profiles)
+        if all_cookies:
+            result[name] = {
+                "found": True,
+                "profiles": [p["profile"] for p in profiles],
+                "cookies": {k: v for k, v in all_cookies.items() if not k.startswith("_")},
+                "cookie_string": _cookie_map_to_string(all_cookies),
+                "encrypted": encrypted,
+            }
+        else:
+            result[name] = {
+                "found": False,
+                "profiles": [p["profile"] for p in profiles],
+                "encrypted": encrypted,
+                "error": "Cookies found but could not be decrypted (try manual paste)",
+            }
+
+    return result
+
+
+def cmd_read(browser, profile_name=None):
+    if browser == "firefox":
+        for p in _find_firefox_profiles():
+            if profile_name and p["profile"] != profile_name:
+                continue
+            c = _read_firefox_cookies(p["path"])
+            if "_error" not in c and c:
+                return {
+                    "browser": "firefox",
+                    "profile": p["profile"],
+                    "cookies": {k: v for k, v in c.items() if not k.startswith("_")},
+                    "cookie_string": _cookie_map_to_string(c),
+                }
+        return {"browser": "firefox", "error": "No cookies found"}
+
+    for name, base_dir in CHROMIUM_BASED:
+        if name != browser:
+            continue
+        for p in _find_chromium_profiles(name, base_dir):
+            if profile_name and p["profile"] != profile_name:
+                continue
+            c = _read_chromium_cookies(name, p)
+            if "_error" not in c and c:
+                return {
+                    "browser": name,
+                    "profile": p["profile"],
+                    "cookies": {k: v for k, v in c.items() if not k.startswith("_")},
+                    "cookie_string": _cookie_map_to_string(c),
+                }
+            if c:
+                return {"browser": name, "error": "Found but could not decrypt"}
+        return {"browser": name, "error": "No cookies found"}
+
+    return {"error": f"Unknown browser: {browser}"}
+
+
+def cmd_clear(browser):
+    if browser == "firefox":
+        cleared = []
+        locked = []
+        for p in _find_firefox_profiles():
+            try:
+                conn = sqlite3.connect(p["path"])
+                conn.execute(
+                    "DELETE FROM moz_cookies WHERE host LIKE ? OR host LIKE ?",
+                    DOMAIN_FILTERS,
+                )
+                conn.commit()
+                conn.close()
+                cleared.append(p["profile"])
+            except Exception as e:
+                locked.append({"profile": p["profile"], "error": str(e)})
+        return {"ok": True, "cleared": cleared, "locked": locked}
+
+    for name, base_dir in CHROMIUM_BASED:
+        if name != browser:
+            continue
+        cleared = []
+        locked = []
+        for p in _find_chromium_profiles(name, base_dir):
+            try:
+                conn = sqlite3.connect(p["path"])
+                conn.execute(
+                    "DELETE FROM cookies WHERE host_key LIKE ? OR host_key LIKE ?",
+                    DOMAIN_FILTERS,
+                )
+                conn.commit()
+                conn.close()
+                cleared.append(p["profile"])
+            except Exception as e:
+                locked.append({"profile": p["profile"], "error": str(e)})
+        return {"ok": True, "cleared": cleared, "locked": locked}
+
+    return {"error": f"Unknown browser: {browser}"}
+
+
+# ── CLI ───────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(description="Read AnimePahe cookies from browsers")
+    parser.add_argument("command", choices=["detect", "read", "clear"])
+    parser.add_argument("--browser", "-b", help="Browser name (firefox, chrome, brave, edge)")
+    parser.add_argument("--profile", "-p", help="Profile name (optional)")
+    args = parser.parse_args()
+
+    if args.command == "detect":
+        result = cmd_detect()
+    elif args.command == "read":
+        if not args.browser:
+            print(json.dumps({"error": "--browser is required for read"}))
+            sys.exit(1)
+        result = cmd_read(args.browser, args.profile)
+    elif args.command == "clear":
+        if not args.browser:
+            print(json.dumps({"error": "--browser is required for clear"}))
+            sys.exit(1)
+        result = cmd_clear(args.browser)
+
+    print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    main()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ani-auto",
-  "version": "1.4.4",
+  "version": "2.0.0",
   "description": "automatic anime episode downloader",
   "bin": {
     "ani-auto": "src/cli.js"
@@ -8,18 +8,26 @@
   "scripts": {
     "start": "node src/daemon.js",
     "download": "node src/cli.js download",
-    "setup": "node src/cli.js setup"
+    "setup": "node src/cli.js setup",
+    "web": "node src/server.js"
   },
   "dependencies": {
+    "axios": "^1.18.1",
     "chalk": "^4.1.2",
+    "cheerio": "^1.0.0-rc.12",
     "cli-progress": "^3.12.0",
+    "cloudscraper": "^4.6.0",
     "commander": "^12.0.0",
+    "cors": "^2.8.6",
+    "dotenv": "^16.6.1",
+    "express": "^5.2.1",
     "inquirer": "^8.2.6",
+    "jsdom": "^22.1.0",
     "node-fetch": "^2.7.0",
     "ora": "^5.4.1",
-    "puppeteer": "^24.40.0",
-    "puppeteer-extra": "^3.3.6",
-    "puppeteer-extra-plugin-stealth": "^2.11.2",
-    "sql.js": "^1.12.0"
+    "p-limit": "^5.0.0",
+    "playwright": "^1.61.1",
+    "sql.js": "^1.12.0",
+    "ws": "^8.21.0"
   }
 }

package/src/anilist.js

@@ -27,7 +27,15 @@ query ($userName: String, $status: MediaListStatus) {
 
 const VIEWER_QUERY = `
 query {
-    Viewer { id name }
+    Viewer { id name avatar { medium } }
+}`;
+
+const MEDIA_BY_ID_QUERY = `
+query ($id: Int) {
+    Media(id: $id, type: ANIME) {
+        id
+        coverImage { extraLarge large medium }
+    }
 }`;
 
 const SEARCH_QUERY = `
@@ -115,4 +123,9 @@ function pickTitle(titles) {
     return titles.english || titles.romaji || titles.native;
 }
 
-module.exports = { getViewer, getUserList, searchAnime, pickTitle };
+async function getMediaById(anilistId, token = null) {
+    const data = await gqlRequest(MEDIA_BY_ID_QUERY, { id: anilistId }, token);
+    return data.Media || null;
+}
+
+module.exports = { getViewer, getUserList, searchAnime, pickTitle, getMediaById };

package/src/api/anilist.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const { Router } = require('express');
+const { getUserList, searchAnime } = require('../anilist');
+const { loadConfig } = require('../config');
+
+const router = Router();
+
+router.get('/list', async (req, res) => {
+  try {
+    const config = loadConfig();
+    if (!config.anilistUsername) return res.json([]);
+    const statuses = req.query.statuses ? req.query.statuses.split(',') : (config.watchStatuses || ['CURRENT']);
+    const entries = await getUserList(config.anilistUsername, statuses, config.anilistToken || null);
+    res.json(entries);
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+router.get('/search', async (req, res) => {
+  try {
+    const q = req.query.q;
+    if (!q) return res.json([]);
+    const results = await searchAnime(q);
+    res.json(results);
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+module.exports = router;