ani-auto 1.4.3 → 2.0.0

package/anime/readme.md

@@ -0,0 +1,236 @@
+# AnimepaheAPI
+
+An unofficial REST API for [Animepahe](https://animepahe.pw/) that provides access to anime information, episodes, and streaming links with direct download support.
+
+> **⚠️ IMPORTANT NOTICE: API MAYBE Temporarily Paused**  
+> The API maybe temporarily paused due to suspiciously too many requests. My hosted version of this API is only for testing purposes. **You MUST host your own instance** to use the API.
+
+## Features
+
+- 🎯 Get currently airing anime
+- 🔍 Search for specific anime
+- 📋 Browse complete anime list
+- 📺 Get anime details and episodes
+- 🎬 Get streaming links with multiple resolutions
+- 📥 Direct download links with quality options
+- ⚡ Optimized parallel processing for faster responses
+- 📱 Check encoding queue status
+- 🐋 Redis support for improved performance
+- 🛡️ Built-in DDoS protection bypass
+- 🔄 Automatic cookie management
+
+## Installation
+
+```bash
+git clone https://github.com/aor-rex/pahe-api.git
+cd animepahe-api
+npm install
+npx playwright install
+copy .env.example .env
+```
+
+## Usage as a Library
+
+You can also use this project as a **Node.js library** directly in your code without running a server.
+
+**Installation:**
+
+```bash
+npm install github:aor-rex/pahe-api
+```
+
+**Example Usage:**
+
+```javascript
+const animepahe = require("pahe-api");
+
+// Search for anime
+const searchResults = await animepahe.search("title");
+console.log(searchResults);
+
+// Get anime info
+const info = await animepahe.getInfo("title");
+console.log(info);
+
+// Get episode releases
+const episodes = await animepahe.getReleases("title", "episode_desc", 1);
+console.log(episodes);
+
+// Get streaming links (m3u8 URLs and download links)
+const streamingData = await animepahe.getStreamingLinks(
+  "anime-session-id",
+  "episode-session-id",
+);
+console.log(streamingData.sources); // HLS streams
+console.log(streamingData.downloads); // Direct download links
+```
+
+## Deploy
+
+[![Deploy with Vercel](https://vercel.com/button)](https://vercel.com/new/clone?repository-url=https%3A%2F%2Fgithub.com%2FElijahCodes12345%2Fanimepahe-api)
+[![Deploy to Heroku](https://www.herokucdn.com/deploy/button.svg)](https://heroku.com/deploy?template=https://github.com/ElijahCodes12345/animepahe-api)
+[![Deploy on Railway](https://railway.app/button.svg)](https://railway.app/new/template/animepahe-api?referralCode=EgKNlg)
+[![Deploy to Render](https://render.com/images/deploy-to-render-button.svg)](https://render.com/deploy?repo=https://github.com/ElijahCodes12345/animepahe-api)
+
+## Configuration
+
+It works as it is but if you want you can create a `.env` file in the root directory:
+
+```env
+PORT=3000 # Optional
+BASE_URL=https://animepahe.pw # Optional
+USER_AGENT=  # Optional
+COOKIES=     # Optional - for manual cookie management
+USE_PROXY=false
+IFRAME_BASE_URL=kwik.cx # Optional - Base URL for the video iframe (default: kwik.cx)
+PROXIES=     # Optional - comma-separated proxy URLs
+REDIS_URL=   # Optional - Redis connection URL for caching (e.g., redis://user:pass@host:port)
+ALLOWED_ORIGINS= # Optional - CORS configuration (see below)
+RATE_LIMIT_SECRET= # Only set this if you want rate limiting (see Rate Limiting section below)
+RATE_LIMIT_MAX=100 # Max requests per window (when rate limiting is active)
+RATE_LIMIT_WINDOW=900 # Time window in seconds (when rate limiting is active)
+```
+
+### CORS Configuration
+
+By default, the API will allow requests from **all origins** (`*`). To restrict access to specific domains:
+
+```env
+# Allow all origins (default)
+ALLOWED_ORIGINS=*
+
+# Allow single origin
+ALLOWED_ORIGINS=http://localhost:5173
+
+# Allow multiple origins (comma-separated)
+ALLOWED_ORIGINS=http://localhost:5173,https://mywebsite.com,https://another-site.com
+```
+
+### Redis Caching
+
+The API supports Redis caching to improve performance and reduce load on the Animepahe servers. When `REDIS_URL` is provided, responses will be cached with the following durations:
+
+- Queue status: 30 seconds
+- Anime list: 1 hour
+- Anime info: 1 day
+- Play/stream info: 5 hours
+
+You may edit these values as you see fit.
+
+If `REDIS_URL` is not provided, the API will still work without caching.
+
+## Rate Limiting
+
+This API includes optional rate limiting that only activates when the `RATE_LIMIT_SECRET` environment variable is set. This allows you to add rate limiting to your own deployment (like your Vercel instance) without affecting other people who might host their own instances.
+
+To enable rate limiting on your deployment:
+
+1. Set a unique `RATE_LIMIT_SECRET` value (e.g., a random UUID)
+2. Configure `RATE_LIMIT_MAX` (default: 100 requests per window)
+3. Configure `RATE_LIMIT_WINDOW` in seconds (default: 900 seconds = 15 minutes)
+4. Configure `REDIS_URL` for persistent rate limiting across server instances (recommended for production use)
+
+**Note**: Rate limiting requires Redis to function properly. If `REDIS_URL` is not configured, rate limiting will be automatically disabled even if `RATE_LIMIT_SECRET` is set. This ensures that other deployments without Redis continue to work normally.
+
+When rate limiting is active, the API will return HTTP 429 status codes when limits are exceeded, along with rate limit headers:
+
+- `X-RateLimit-Limit`: Maximum requests per window
+- `X-RateLimit-Remaining`: Requests remaining in current window
+- `X-RateLimit-Reset`: Time when the current window resets
+
+## API Endpoints
+
+### Airing Anime
+
+```
+GET /api/airing
+GET /api/airing?page=2
+```
+
+### Search Anime
+
+```
+GET /api/search?q=your_search_query
+GET /api/search?q=your_search_query&page=2
+```
+
+### Anime List
+
+```
+GET /api/anime
+GET /api/anime?tab=A
+GET /api/anime/:tag1/:tag2
+GET /api/anime/:tag1/:tag2?tab=D
+```
+
+tag1 being eg: genre, Theme, etc. tag2 being eg: action, adventure, historical etc.
+Note: For tab use 'hash' instead of '#'
+
+### Anime Information
+
+```
+GET /api/:session  # Get anime details using anime session ID
+GET /api/:session/releases?sort=episode_desc&page=1  # Get episode list
+```
+
+### Streaming & Downloads
+
+```
+GET /api/play/:session?episodeId=example                # With downloads (default)
+GET /api/play/:session?episodeId=example&downloads=false  # Without downloads (faster)
+GET /api/play/download-links?url=https://pahe.win/XYZ # To only get one download link
+```
+
+> **Note:**
+>
+> - `:session` is the anime's unique identifier
+> - `episodeId` is the episode's unique identifier from the /releases endpoint
+> - Use `downloads=false` for faster responses if you only need streaming links
+
+### Queue Status
+
+```
+GET /api/queue
+```
+
+## Error Handling
+
+The API returns errors in this format:
+
+```json
+{
+  "status": 503,
+  "message": "Request failed"
+}
+```
+
+## Technologies Used
+
+- Node.js
+- Express
+- Playwright
+- @sparticuz/chromium
+- Cheerio
+- Axios
+- cloudscraper
+- jsdom
+- vm
+
+## Acknowledgments
+
+Special thanks to:
+
+- [Pal-droid](https://github.com/Pal-droid) for assistance in improving the project's logic and features.
+- All the developers whose libraries made this project possible.
+
+## License
+
+This project is licensed under the MIT License.
+
+## Disclaimer
+
+This project is not affiliated with or endorsed by Animepahe. It's an unofficial API created for educational purposes.
+
+## Support
+
+If you find this project helpful, please give it a ⭐️ on GitHub!

package/anime/routes/animeInfoRoutes.js

@@ -0,0 +1,9 @@
+const express = require('express');
+const AnimeInfoController = require('../controllers/animeInfoController');
+
+const router = express.Router();
+
+router.get('/:id', AnimeInfoController.getAnimeInfo);
+router.get('/:id/releases', AnimeInfoController.getAnimeReleases);   
+
+module.exports = router;

package/anime/routes/animeListRoutes.js

@@ -0,0 +1,9 @@
+const express = require("express");
+const AnimeListController = require("../controllers/animeListController");
+
+const router = express.Router();
+
+// Browse anime list with query params: ?page=2&tab=A&genre=action
+router.get("/list", AnimeListController.getAllAnime);
+
+module.exports = router;

package/anime/routes/homeRoutes.js

@@ -0,0 +1,10 @@
+const express = require('express');
+const cache = require('../middleware/cache');
+const HomeController = require('../controllers/homeController');
+
+const router = express.Router();
+
+router.get('/airing', cache(30), HomeController.getAiringAnime);
+router.get('/search', cache(120), HomeController.searchAnime);
+
+module.exports = router;

package/anime/routes/playRoutes.js

@@ -0,0 +1,11 @@
+const express = require("express");
+const PlayController = require("../controllers/playController");
+
+const router = express.Router();
+
+// NOTE: /download-links endpoint removed — was deprecated (501) due to
+// Cloudflare on kwik.cx. Use /:id/:ep → sources[].download instead.
+router.get("/download-proxy", PlayController.proxyDownload);
+router.get("/:id/:ep", PlayController.getStreamingLinks);
+
+module.exports = router;

package/anime/routes/queueRoutes.js

@@ -0,0 +1,8 @@
+const express = require('express');
+const QueueController = require('../controllers/queueController');
+
+const router = express.Router();
+
+router.get('/queue', QueueController.getQueue);
+
+module.exports = router;

package/anime/routes/testRoutes.js

@@ -0,0 +1,325 @@
+const express = require("express");
+const router = express.Router();
+const TestController = require("../controllers/testController");
+const { launchBrowser } = require("../utils/browser");
+
+router.get("/kwik-test", TestController.resolveKwik);
+
+router.get("/downlod-test", TestController.download);
+
+router.get("/test", async (req, res) => {
+  try {
+    const playPageUrl =
+      "https://animepahe.pw/play/9a16dfb8-8ffc-a0b0-6508-1b291afa04a7/b3a2934c2694eb256d0258ea1fea00dbf620eddd57cbadb97bec7019dc18dcc9";
+
+    const browser = await launchBrowser();
+    const context = await browser.newContext({
+      userAgent:
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+      viewport: { width: 1280, height: 800 },
+      javaScriptEnabled: true,
+      // Add extra headers to appear more like a real browser
+      extraHTTPHeaders: {
+        Accept:
+          "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
+        "Accept-Language": "en-US,en;q=0.9",
+        "Accept-Encoding": "gzip, deflate, br",
+        DNT: "1",
+        Connection: "keep-alive",
+        "Upgrade-Insecure-Requests": "1",
+      },
+    });
+
+    const cookies = await context.cookies();
+    const relevantCookies = cookies.filter(
+      (cookie) =>
+        cookie.name.includes("cf_clearance") ||
+        cookie.name.includes("srvs") ||
+        cookie.name.includes("__cf") ||
+        cookie.name.includes("_cflb") ||
+        cookie.domain.includes("kwik.si") ||
+        cookie.domain.includes(".si"),
+    );
+
+    console.log(relevantCookies);
+
+    const page = await context.newPage();
+
+    // Enhanced stealth protections
+    await page.addInitScript(() => {
+      // Hide webdriver property
+      Object.defineProperty(navigator, "webdriver", { get: () => undefined });
+
+      // Mock plugins
+      Object.defineProperty(navigator, "plugins", {
+        get: () => [
+          { name: "Chrome PDF Plugin" },
+          { name: "Chrome PDF Viewer" },
+          { name: "Native Client" },
+        ],
+      });
+
+      // Mock languages
+      Object.defineProperty(navigator, "languages", {
+        get: () => ["en-US", "en"],
+      });
+
+      // Mock chrome object
+      window.chrome = { runtime: {} };
+
+      // Mock permissions
+      const originalQuery = window.navigator.permissions.query;
+      window.navigator.permissions.query = (parameters) =>
+        parameters.name === "notifications"
+          ? Promise.resolve({ state: Notification.permission })
+          : originalQuery(parameters);
+
+      // Mock screen properties
+      Object.defineProperty(screen, "colorDepth", { get: () => 24 });
+      Object.defineProperty(screen, "pixelDepth", { get: () => 24 });
+
+      // Remove automation indicators
+      delete window.cdc_adoQpoasnfa76pfcZLmcfl_Array;
+      delete window.cdc_adoQpoasnfa76pfcZLmcfl_Promise;
+      delete window.cdc_adoQpoasnfa76pfcZLmcfl_Symbol;
+    });
+
+    // Block ads and tracking
+    await page.route("**/*", (route) => {
+      const url = route.request().url();
+      if (
+        /ads|doubleclick|popunder|popads|brunetsmolted|duelistdoesnt|kryptonnutlet|whitebit|garsilgilpey|analytics|googletagmanager|facebook|twitter/.test(
+          url,
+        )
+      ) {
+        return route.abort();
+      }
+      route.continue();
+    });
+
+    console.log("Navigating to Animepahe...");
+    await page.goto(playPageUrl, { waitUntil: "networkidle", timeout: 60000 });
+
+    // Wait a bit for any initial scripts to load
+    await page.waitForTimeout(3000);
+
+    let kwikResponse = null;
+    let kwikUrl = null;
+
+    // Enhanced route interception with better headers
+    await page.route("**/kwik.si/e/**", async (route) => {
+      const url = route.request().url();
+      console.log("Intercepting kwik route:", url);
+      kwikUrl = url;
+
+      try {
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+
+        const response = await route.fetch({
+          headers: {
+            ...route.request().headers(),
+            Referer: playPageUrl,
+            Origin: "https://animepahe.pw",
+            "Sec-Fetch-Dest": "iframe",
+            "Sec-Fetch-Mode": "navigate",
+            "Sec-Fetch-Site": "cross-site",
+            "Sec-Ch-Ua":
+              '"Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"',
+            "Sec-Ch-Ua-Mobile": "?0",
+            "Sec-Ch-Ua-Platform": '"Windows"',
+          },
+        });
+
+        const responseText = await response.text();
+
+        if (
+          responseText.includes("Just a moment") ||
+          responseText.includes("challenge")
+        ) {
+          console.log(
+            "Received Cloudflare challenge, trying alternative approach...",
+          );
+
+          await route.continue();
+
+          setTimeout(async () => {
+            try {
+              const delayedResponse = await page.evaluate(async (url) => {
+                const response = await fetch(url, {
+                  headers: {
+                    "User-Agent": navigator.userAgent,
+                    Referer: window.location.href,
+                    Accept: "*/*",
+                    "Accept-Language": "en-US,en;q=0.9",
+                    "Cache-Control": "no-cache",
+                  },
+                });
+                return await response.text();
+              }, url);
+
+              if (
+                delayedResponse &&
+                !delayedResponse.includes("Just a moment")
+              ) {
+                kwikResponse = delayedResponse;
+                console.log(
+                  "Successfully bypassed Cloudflare via delayed fetch",
+                );
+              }
+            } catch (err) {
+              console.error("Delayed fetch failed:", err.message);
+            }
+          }, 5000);
+        } else {
+          kwikResponse = responseText;
+          console.log("Captured kwik response via route interception");
+
+          await route.fulfill({
+            response: response,
+          });
+        }
+      } catch (err) {
+        console.error("Route interception failed:", err.message);
+        route.continue();
+      }
+    });
+
+    // Click the load button
+    await page.waitForSelector(".click-to-load .reload", { timeout: 45000 });
+    await page.click(".click-to-load .reload");
+    console.log("Clicked load button, waiting for kwik response...");
+
+    // Wait longer for Cloudflare bypass
+    const maxWait = 60000;
+    const interval = 2000;
+    let elapsed = 0;
+
+    while (!kwikResponse && elapsed < maxWait) {
+      await page.waitForTimeout(interval);
+      elapsed += interval;
+      console.log(`Waiting for kwik response... ${elapsed / 1000}s`);
+
+      // Try alternative approach if we're waiting too long
+      if (elapsed === 20000 && kwikUrl && !kwikResponse) {
+        console.log("Trying direct iframe navigation...");
+        try {
+          // Navigate to the kwik URL directly in a new page
+          const kwikPage = await context.newPage();
+          await kwikPage.goto(kwikUrl, {
+            waitUntil: "networkidle",
+            timeout: 30000,
+          });
+
+          // Wait for Cloudflare challenge to complete
+          await kwikPage.waitForTimeout(10000);
+
+          const content = await kwikPage.content();
+          if (!content.includes("Just a moment")) {
+            kwikResponse = content;
+            console.log("Successfully got content via direct navigation");
+            console.log("Cookies", cookies);
+          }
+
+          await kwikPage.close();
+        } catch (err) {
+          console.error("Direct navigation failed:", err.message);
+        }
+      }
+    }
+
+    await browser.close();
+
+    if (!kwikResponse) {
+      throw new Error(
+        `kwik response not captured within time limit. URL detected: ${kwikUrl || "none"}`,
+      );
+    }
+
+    // Check if we still have Cloudflare challenge in the response
+    if (
+      kwikResponse.includes("Just a moment") ||
+      kwikResponse.includes("Checking your browser")
+    ) {
+      return res.status(202).json({
+        message: "Cloudflare challenge detected",
+        kwikUrl: kwikUrl,
+        note: "Try again in a few moments or implement additional bypass techniques",
+        preview: kwikResponse.slice(0, 500),
+      });
+    }
+
+    // Extract video URL from kwik.si page
+    let videoUrl = null;
+    let extractedData = {};
+
+    try {
+      // Look for common video URL patterns in kwik.si
+      const videoUrlMatches =
+        kwikResponse.match(/source.*?src=["']([^"']+)["']/i) ||
+        kwikResponse.match(/file:\s*["']([^"']+)["']/i) ||
+        kwikResponse.match(/src=["']([^"']+\.mp4[^"']*)["']/i) ||
+        kwikResponse.match(/https?:\/\/[^"'\s]+\.mp4[^"'\s]*/i);
+
+      if (videoUrlMatches) {
+        videoUrl = videoUrlMatches[1] || videoUrlMatches[0];
+        extractedData.videoUrl = videoUrl;
+      }
+
+      // Look for video title
+      const titleMatch = kwikResponse.match(/<title>([^<]+)<\/title>/i);
+      if (titleMatch) {
+        extractedData.title = titleMatch[1].replace(/\.mp4$/, "");
+      }
+
+      // Look for Plyr or other video player configurations
+      const plyrMatch = kwikResponse.match(
+        /new\s+Plyr[^{]*{[^}]*source[^}]*}[^}]*}/i,
+      );
+      if (plyrMatch) {
+        extractedData.playerConfig = plyrMatch[0];
+      }
+
+      // Look for JavaScript video source assignments
+      const jsVideoMatch =
+        kwikResponse.match(/video\.src\s*=\s*["']([^"']+)["']/i) ||
+        kwikResponse.match(
+          /setAttribute\s*\(\s*["']src["']\s*,\s*["']([^"']+)["']/i,
+        );
+      if (jsVideoMatch) {
+        extractedData.jsVideoSrc = jsVideoMatch[1];
+        if (!videoUrl) videoUrl = jsVideoMatch[1];
+      }
+    } catch (parseError) {
+      console.error("Error parsing kwik response:", parseError.message);
+    }
+
+    return res.json({
+      message: "Success",
+      kwikUrl: kwikUrl,
+      videoUrl: videoUrl,
+      extractedData: extractedData,
+      preview: kwikResponse.slice(0, 500),
+      contentLength: kwikResponse.length,
+      captureMethod: "Enhanced route interception with Cloudflare bypass",
+      hasVideoUrl: !!videoUrl,
+    });
+  } catch (error) {
+    console.error("Error in /test:", error.message);
+    return res.status(500).json({
+      error: error.message,
+      details: "Check server logs for more information",
+    });
+  }
+});
+
+module.exports = router;
+
+// const express = require('express');
+// const router = express.Router();
+// const { launchBrowser } = require('../utils/browser');
+
+// router.get('/test', async (req, res) => {
+//     res.status(200).json({ message: "A testing route"});
+// });
+
+// module.exports = router;

package/anime/routes/webhookRoutes.js

@@ -0,0 +1,23 @@
+const express = require("express");
+const { runTick } = require("../utils/webhookNotifier");
+
+const router = express.Router();
+
+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 || "check failed" });
+  }
+});
+
+module.exports = router;