ani-auto 1.4.4 → 2.0.0

package/anime/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 ElijahCodes12345
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/anime/api/index.js

@@ -0,0 +1,110 @@
+const express = require("express");
+const cors = require("cors");
+const Config = require("../utils/config");
+const { errorHandler, CustomError } = require("../middleware/errorHandler");
+const rateLimiter = require("../middleware/rateLimiter");
+const homeRoutes = require("../routes/homeRoutes");
+const queueRoutes = require("../routes/queueRoutes");
+const animeListRoutes = require("../routes/animeListRoutes");
+const animeInfoRoutes = require("../routes/animeInfoRoutes");
+const playRoutes = require("../routes/playRoutes");
+const webhookRoutes = require("../routes/webhookRoutes");
+const PlayController = require("../controllers/playController");
+const cache = require("../middleware/cache");
+const testRoutes = require("../routes/testRoutes");
+const { startWebhookNotifier } = require("../utils/webhookNotifier");
+
+const app = express();
+
+// Load environment variables into Config
+try {
+  Config.validate();
+  Config.loadFromEnv();
+  console.log("\x1b[36m%s\x1b[0m", "Configuration set!.");
+} catch (error) {
+  console.error(error.message);
+  throw error;
+}
+
+startWebhookNotifier();
+
+// CORS Configuration
+const corsOptions = {
+  origin: function (origin, callback) {
+    if (!origin) return callback(null, true);
+
+    const allowedOrigins = process.env.ALLOWED_ORIGINS
+      ? process.env.ALLOWED_ORIGINS.split(",").map((o) => o.trim())
+      : ["*"]; // Default: allow all origins
+
+    if (allowedOrigins.includes("*")) {
+      return callback(null, true);
+    }
+
+    if (allowedOrigins.includes(origin)) {
+      callback(null, true);
+    } else {
+      callback(new Error("Not allowed by CORS"));
+    }
+  },
+  credentials: true,
+  methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+  allowedHeaders: ["Content-Type", "Authorization", "X-Requested-With"],
+};
+
+app.use(cors(corsOptions));
+
+// Global request/response timeout — prevents slow upstream requests from hanging
+app.use((req, res, next) => {
+  req.setTimeout(150000);
+  res.setTimeout(150000);
+  next();
+});
+
+// Middleware to set hostUrl
+app.use((req, res, next) => {
+  const protocol = req.headers["x-forwarded-proto"] || "https";
+  const host = req.headers.host;
+  Config.setHostUrl(protocol, host);
+  next();
+});
+
+// Apply rate limiting only if RATE_LIMIT_SECRET is set (only affects your deployment)
+app.use(rateLimiter);
+
+// Test routes - only expose in development, not production
+if (process.env.NODE_ENV !== "production") {
+  app.use("/api", testRoutes);
+}
+
+app.use("/api", homeRoutes); // caching done in homeRoutes (30s airing, 120s search)
+app.use("/api", webhookRoutes);
+app.use("/api", cache(30), queueRoutes); // 30 seconds
+app.use("/api", cache(18000), animeListRoutes); // 5 hours
+app.use("/api", cache(86400), animeInfoRoutes); // 24 hours
+app.use("/api", cache(3600), playRoutes); // 1 hour
+
+app.use((req, res, next) => {
+  if (!req.route) {
+    next(
+      new CustomError(
+        "Route not found. Please check the API documentation at https://github.com/ElijahCodes12345/animepahe-api",
+        404,
+      ),
+    );
+  } else {
+    next();
+  }
+});
+
+// Error handling middleware
+app.use(errorHandler);
+
+module.exports = app.handler = (req, res) => {
+  let path = req.url.replace(/^\/api/, "");
+  if (!path.startsWith("/")) {
+    path = "/" + path;
+  }
+  req.url = "/api" + path;
+  return app(req, res);
+};

package/anime/app.js

@@ -0,0 +1,79 @@
+const express = require("express");
+const Config = require("./utils/config");
+const homeRoutes = require("./routes/homeRoutes");
+const queueRoutes = require("./routes/queueRoutes");
+const animeListRoutes = require("./routes/animeListRoutes");
+const animeInfoRoutes = require("./routes/animeInfoRoutes");
+const playRoutes = require("./routes/playRoutes");
+const PlayController = require("./controllers/playController");
+const cache = require("./middleware/cache");
+const Animepahe = require("./scrapers/animepahe");
+const flaresolverr = require("./utils/flaresolverr");
+const { startWebhookNotifier, runTick } = require("./utils/webhookNotifier");
+
+// Load environment variables into Config
+try {
+  Config.validate();
+  Config.loadFromEnv();
+  console.log("\x1b[36m%s\x1b[0m", "Anime configuration loaded.");
+} catch (error) {
+  console.error("Anime config error:", error.message);
+}
+
+// ─── S1+S4: Pre-fetch cookies and solve DDoS-Guard at startup ───
+// This launches a browser ONCE, solves the DDoS-Guard challenge,
+// saves cookies to disk, and keeps the browser alive for fallback.
+// All subsequent requests will use axios + saved cookies (~1-2s)
+// instead of launching a new browser per request (~40-60s).
+//
+// This is non-blocking — the server starts immediately and cookies
+// are ready in the background. If pre-fetch fails, requests fall back
+// to Playwright automatically.
+console.log("\x1b[36m%s\x1b[0m", "Starting cookie pre-fetch (non-blocking)...");
+if (!flaresolverr.isEnabled()) {
+  console.warn(
+    "[anime] FlareSolverr is not enabled. Browser cookie fallback is disabled for this deployment.",
+  );
+}
+Animepahe.initialize().catch((err) =>
+  console.error("[Startup] Cookie pre-fetch error:", err.message),
+);
+startWebhookNotifier();
+
+const router = express.Router();
+
+// Global request/response timeout — prevents slow upstream requests from hanging
+router.use((req, res, next) => {
+  req.setTimeout(150000);
+  res.setTimeout(150000);
+  next();
+});
+
+router.get("/download-proxy", PlayController.proxyDownload);
+router.post("/webhook-check", express.json(), async (req, res) => {
+  const expected = process.env.WEBHOOK_SECRET || "";
+  const provided = req.headers["x-webhook-secret"] || "";
+
+  if (expected && provided !== expected) {
+    return res.status(401).json({ error: "unauthorized" });
+  }
+
+  try {
+    const animeSession = String(req.body?.anime_session || "").trim() || null;
+    const result = await runTick({ animeSession });
+    return res.json({ ok: true, ...result });
+  } catch (err) {
+    return res.status(500).json({ error: err.message || "webhook-check failed" });
+  }
+});
+
+// ─── Anime routes ───
+// NOTE: animeInfoRoutes (/:id, /:id/releases) MUST come before playRoutes (/:id/:ep)
+// so that /:id/releases is matched before /:id/:ep treats "releases" as an episode ID.
+router.use("", homeRoutes);
+router.use("", cache(30), queueRoutes); // 30 seconds
+router.use("", cache(18000), animeListRoutes); // 5 hours
+router.use("", cache(86400), animeInfoRoutes); // 1 day
+router.use("", cache(3600), playRoutes); // 1 hour
+
+module.exports = router;

package/anime/controllers/animeInfoController.js

@@ -0,0 +1,48 @@
+const AnimeInfoModel = require('../models/animeInfoModel');
+const { CustomError } = require('../middleware/errorHandler');
+
+class AnimeInfoController {
+    static async getAnimeInfo(req, res, next) {
+        try {
+            const animeId = req.params.id;
+            
+            if (!animeId) {
+                throw new CustomError('Anime ID is required', 400);
+            }
+
+            const animeInfo = await AnimeInfoModel.getAnimeInfo(animeId);
+            
+            if (!animeInfo) {
+                throw new CustomError('Anime not found', 404);
+            }
+
+            return res.json(animeInfo);
+        } catch (error) {
+            next(error);
+        }
+    }
+    
+    static async getAnimeReleases(req, res, next) {
+        try {
+            const animeId = req.params.id;
+            const sort = req.query.sort || 'episode_desc';
+            const page = parseInt(req.query.page, 10) || 1; 
+
+            if (!animeId) {
+                throw new CustomError('Anime ID is required', 400);
+            }
+
+            const animeReleases = await AnimeInfoModel.getAnimeReleases(animeId, sort, page);
+            
+            if (!animeReleases) {
+                throw new CustomError('No releases found', 404);
+            }
+
+            return res.json(animeReleases);
+        } catch (error) {
+            next(error);
+        }
+    }
+}
+
+module.exports = AnimeInfoController;

package/anime/controllers/animeListController.js

@@ -0,0 +1,21 @@
+const AnimeListModel = require("../models/animeListModel");
+const { CustomError } = require("../middleware/errorHandler");
+
+class AnimeListController {
+  static async getAllAnime(req, res, next) {
+    try {
+      const { page, tab, genre } = req.query;
+      const animeList = await AnimeListModel.getAnimeList(page, tab, genre);
+
+      if (!animeList) {
+        throw new CustomError("Failed to fetch anime list", 404);
+      }
+
+      return res.json(animeList);
+    } catch (error) {
+      next(error);
+    }
+  }
+}
+
+module.exports = AnimeListController;

package/anime/controllers/homeController.js

@@ -0,0 +1,42 @@
+const HomeModel = require('../models/homeModel');
+const { CustomError } = require('../middleware/errorHandler');
+
+class HomeController {
+    static async getAiringAnime(req, res, next) {
+        try {
+            const page = parseInt(req.query.page, 10) || 1; 
+            const airingAnime = await HomeModel.getAiringAnime(page);
+            
+            if (!airingAnime) {
+                throw new CustomError('No airing anime found', 404);
+            }
+            
+            return res.json(airingAnime);
+        } catch (error) {
+            next(error);
+        }
+    }
+
+    static async searchAnime(req, res, next) {
+        try {
+            const query = req.query.q;
+            const page = parseInt(req.query.page, 10) || 1; 
+            
+            if (!query) {
+                throw new CustomError('Search query is required', 400);
+            }
+
+            const searchResults = await HomeModel.searchAnime(query, page);
+            
+            if (!searchResults) {
+                throw new CustomError('No results found', 404);
+            }
+            
+            return res.json(searchResults);
+        } catch (error) {
+            next(error);
+        }
+    }
+}
+
+module.exports = HomeController;

package/anime/controllers/playController.js

@@ -0,0 +1,140 @@
+const axios = require("axios");
+const RequestManager = require("../utils/requestManager");
+const PlayModel = require("../models/playModel");
+const Animepahe = require("../scrapers/animepahe");
+const flaresolverr = require("../utils/flaresolverr");
+const Config = require("../utils/config");
+const { CustomError } = require("../middleware/errorHandler");
+
+class PlayController {
+  static async getStreamingLinks(req, res, next) {
+    try {
+      const { id, ep } = req.params;
+      const { downloads } = req.query;
+
+      if (!id || !ep) {
+        throw new CustomError("Both id and ep are required", 400);
+      }
+
+      // Parse downloads query parameter (defaults to true)
+      // user can pass ?downloads=false or ?downloads=0 to skip downloads
+      const includeDownloads =
+        downloads === undefined || downloads === "true" || downloads === "1";
+
+      // console.log(`[PlayController] Request query downloads: '${downloads}' -> includeDownloads: ${includeDownloads}`);
+
+      const links = await PlayModel.getStreamingLinks(id, ep, includeDownloads);
+
+      return res.json(links);
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  static async proxyDownload(req, res, next) {
+    try {
+      const target = String(req.query.url || '').trim();
+      if (!target) {
+        throw new CustomError('url is required', 400);
+      }
+
+      let parsed;
+      try {
+        parsed = new URL(target);
+      } catch (_) {
+        throw new CustomError('invalid url', 400);
+      }
+
+      const host = parsed.hostname.toLowerCase();
+      const allowedHosts = [
+        'uwucdn', 'owocdn', 'hakunaymatata', 'animepahe', 'pahe', 'kwik'
+      ];
+      if (!allowedHosts.some((token) => host.includes(token))) {
+        throw new CustomError('domain not allowed', 403);
+      }
+
+      const headers = {
+        'User-Agent': Config.userAgent,
+        Referer: 'https://kwik.cx/',
+        Origin: 'https://kwik.cx',
+      };
+      if (req.headers.range) {
+        headers.Range = req.headers.range;
+      }
+
+      const response = await RequestManager.cloudscraperGet(target, {
+        headers,
+        encoding: null,
+        timeout: 60000,
+      });
+
+      if (response.statusCode >= 400) {
+        const preview = String(response.body || '').slice(0, 160).replace(/\s+/g, ' ');
+        console.error(`[download-proxy] upstream blocked: status=${response.statusCode} host=${host} preview=${preview}`);
+        throw new CustomError('download upstream blocked', 502);
+      }
+
+      const passthrough = [
+        'content-type', 'content-length', 'content-disposition',
+        'accept-ranges', 'content-range', 'etag', 'last-modified'
+      ];
+      for (const key of passthrough) {
+        const value = response.headers[key];
+        if (value) res.setHeader(key, value);
+      }
+
+      const body = response.body;
+      if (Buffer.isBuffer(body)) {
+        res.status(response.statusCode);
+        res.end(body);
+      } else if (typeof body === 'string') {
+        const buf = Buffer.from(body, 'utf8');
+        if (!res.getHeader('content-length')) {
+          res.setHeader('content-length', buf.length);
+        }
+        res.status(response.statusCode);
+        res.end(buf);
+      } else {
+        res.status(response.statusCode);
+        body.pipe(res);
+      }
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  // @deprecated — Broken since kwik.cx added Cloudflare protection.
+  // Direct MP4 download URLs are already available in /api/play/:id?episodeId=
+  // under sources[].download and downloads[].download.
+  // To fix: replace cloudscraper with Playwright in extractKwikUrl/getKwikDownloadUrl.
+  static getDownloadLinks(req, res) {
+    const { url } = req.query;
+
+    if (!url) {
+      return res.status(400).json({
+        status: 400,
+        message: "Url is required",
+      });
+    }
+
+    return res.json({
+      status: 501,
+      message:
+        "DEPRECATED: This endpoint is broken due to Cloudflare protection on kwik.cx.",
+      workaround:
+        "Use /api/play/:id?episodeId= instead. Direct MP4 download URLs are provided under sources[].download and downloads[].download.",
+      fix_hint:
+        "To restore this endpoint, replace cloudscraper with Playwright in scrapers/animepahe.js → extractKwikUrl() and getKwikDownloadUrl().",
+    });
+
+    // Original code preserved below for future restoration:
+    // try {
+    //   const links = await PlayModel.getDownloadLinks(url);
+    //   return res.json(links);
+    // } catch (error) {
+    //   next(error);
+    // }
+  }
+}
+
+module.exports = PlayController;

package/anime/controllers/queueController.js

@@ -0,0 +1,20 @@
+const QueueModel = require('../models/queueModel');
+const { CustomError } = require('../middleware/errorHandler');
+
+class QueueController {
+    static async getQueue(req, res, next) {
+        try {
+            const queue = await QueueModel.getQueue();
+            
+            if (!queue) {
+                throw new CustomError('Failed to fetch queue data', 404);
+            }
+
+            return res.json(queue);
+        } catch (error) {
+            next(error);
+        }
+    }
+}
+
+module.exports = QueueController;