ani-auto 1.4.3 → 2.0.0

package/anime/test-server.js

@@ -0,0 +1,10 @@
+/**
+ * Test server wrapper for standalone pahe-api testing.
+ * Usage: node test-server.js
+ */
+const app = require('./app');
+const PORT = process.env.PORT || 3000;
+
+app.listen(PORT, () => {
+  console.log(`API running on http://localhost:${PORT}`);
+});

package/anime/test.sh

@@ -0,0 +1,275 @@
+#!/usr/bin/env bash
+# ============================================================
+# pahe-api — Full endpoint test with response validation
+# Usage: chmod +x test.sh && ./test.sh
+# ============================================================
+
+BASE="http://localhost:3000"
+PASS=0
+FAIL=0
+WARN=0
+
+# Colors
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+NC='\033[0m'
+
+# Helper: validate JSON structure
+check() {
+    local name="$1"
+    local json="$2"
+    local path="$3"
+    local expected_type="$4"
+
+    local val
+    val=$(echo "$json" | python3 -c "
+import sys, json
+try:
+    d = json.load(sys.stdin)
+    keys = '$path'.split('.')
+    obj = d
+    for k in keys:
+        if k.isdigit():
+            obj = obj[int(k)]
+        else:
+            obj = obj[k]
+    print(type(obj).__name__, repr(obj)[:80])
+except Exception as e:
+    print('ERROR', str(e))
+" 2>&1)
+
+    local actual_type="${val%% *}"
+    local actual_val="${val#* }"
+
+    if [[ "$val" == ERROR* ]]; then
+        echo -e "  ${RED}✗ FAIL${NC} $name → path '$path' not found: ${actual_val#ERROR }"
+        ((FAIL++))
+    elif [[ -n "$expected_type" && "$actual_type" != "$expected_type" ]]; then
+        echo -e "  ${YELLOW}⚠ WARN${NC} $name → $path: expected $expected_type, got $actual_type ($actual_val)"
+        ((WARN++))
+    else
+        echo -e "  ${GREEN}✓ PASS${NC} $name → $path: $actual_type $actual_val"
+        ((PASS++))
+    fi
+}
+
+# Helper: check HTTP status
+status_check() {
+    local name="$1"
+    local url="$2"
+    local expected_code="$3"
+    local max_time="${4:-30}"
+
+    local response
+    response=$(curl -s -w "\n%{http_code}" --connect-timeout 10 --max-time "$max_time" "$url" 2>&1)
+    local http_code
+    http_code=$(echo "$response" | tail -1)
+    local body
+    body=$(echo "$response" | sed '$d')
+
+    if [[ "$http_code" == "$expected_code" ]]; then
+        echo -e "${GREEN}✓ PASS${NC} [$http_code] $name"
+        ((PASS++))
+        echo "$body"
+    else
+        echo -e "${RED}✗ FAIL${NC} [$http_code] $name (expected $expected_code)"
+        ((FAIL++))
+        echo "$body" | head -5
+    fi
+}
+
+echo -e "${CYAN}============================================${NC}"
+echo -e "${CYAN}  pahe-api — Endpoint Validation Tests${NC}"
+echo -e "${CYAN}============================================${NC}"
+echo ""
+
+# ────────────────────────────────────────────────────────────
+echo -e "${CYAN}[1/13] GET /airing${NC}"
+json=$(status_check "Airing anime" "$BASE/airing" "200")
+echo ""
+if echo "$json" | python3 -c "import sys,json; json.load(sys.stdin)" 2>/dev/null; then
+    check "paginationInfo.total" "$json" "paginationInfo.total" "int"
+    check "paginationInfo.perPage" "$json" "paginationInfo.perPage" "int"
+    check "paginationInfo.currentPage" "$json" "paginationInfo.currentPage" "int"
+    check "data (array)" "$json" "data" "list"
+    check "data[0].id" "$json" "data.0.id" "int"
+    check "data[0].title" "$json" "data.0.title" "str"
+    check "data[0].episode" "$json" "data.0.episode" "int"
+    check "data[0].fansub" "$json" "data.0.fansub" "str"
+    check "data[0].image (URL)" "$json" "data.0.image" "str"
+    check "data[0].session" "$json" "data.0.session" "str"
+fi
+echo ""
+
+# ────────────────────────────────────────────────────────────
+echo -e "${CYAN}[2/13] GET /search?q=naruto${NC}"
+json=$(status_check "Search anime" "$BASE/search?q=naruto" "200")
+echo ""
+if echo "$json" | python3 -c "import sys,json; json.load(sys.stdin)" 2>/dev/null; then
+    check "paginationInfo.total" "$json" "paginationInfo.total" "int"
+    check "data (array)" "$json" "data" "list"
+    check "data[0].id" "$json" "data.0.id" "int"
+    check "data[0].title" "$json" "data.0.title" "str"
+    check "data[0].status" "$json" "data.0.status" "str"
+    check "data[0].type" "$json" "data.0.type" "str"
+    check "data[0].episodes" "$json" "data.0.episodes" "int"
+    check "data[0].score" "$json" "data.0.score" "float"
+    check "data[0].year" "$json" "data.0.year" "int"
+    check "data[0].poster (URL)" "$json" "data.0.poster" "str"
+    check "data[0].session" "$json" "data.0.session" "str"
+fi
+echo ""
+
+# ────────────────────────────────────────────────────────────
+echo -e "${CYAN}[3/13] GET /search (page 2)?q=naruto&page=2${NC}"
+json=$(status_check "Search (page 2)" "$BASE/search?q=naruto&page=2" "200")
+echo ""
+if echo "$json" | python3 -c "import sys,json; json.load(sys.stdin)" 2>/dev/null; then
+    check "paginationInfo.currentPage" "$json" "paginationInfo.currentPage" "int"
+    check "data (array)" "$json" "data" "list"
+fi
+echo ""
+
+# ────────────────────────────────────────────────────────────
+echo -e "${CYAN}[4/13] GET /list (A-Z) (A-Z List)${NC}"
+json=$(status_check "Anime list" "$BASE/list" "200")
+echo ""
+if echo "$json" | python3 -c "import sys,json; json.load(sys.stdin)" 2>/dev/null; then
+    check "data (array)" "$json" "0" "list"
+    check "[0].title" "$json" "0.title" "str"
+    check "[0].url" "$json" "0.url" "str"
+fi
+echo ""
+
+# ────────────────────────────────────────────────────────────
+echo -e "${CYAN}[5/13] GET /list?tab=N (by letter)${NC}"
+json=$(status_check "Anime list (letter N)" "$BASE/list?tab=N" "200")
+echo ""
+if echo "$json" | python3 -c "import sys,json; json.load(sys.stdin)" 2>/dev/null; then
+    check "[0].title" "$json" "0.title" "str"
+    check "[0].url" "$json" "0.url" "str"
+fi
+echo ""
+
+# ────────────────────────────────────────────────────────────
+echo -e "${CYAN}[6/13] GET /list/genre/action (by tag)${NC}"
+json=$(status_check "Anime list (genre/action)" "$BASE/list/genre/action" "200")
+echo ""
+if echo "$json" | python3 -c "import sys,json; json.load(sys.stdin)" 2>/dev/null; then
+    check "[0].title" "$json" "0.title" "str"
+    check "[0].url" "$json" "0.url" "str"
+fi
+echo ""
+
+# ────────────────────────────────────────────────────────────
+echo -e "${CYAN}[7/13] GET /:id (Anime Info) (Anime Info)${NC}"
+ANIME_ID="66e575d9-1c71-2117-bf09-acef2f6a0deb"
+json=$(status_check "Anime info (Naruto)" "$BASE/$ANIME_ID" "200")
+echo ""
+if echo "$json" | python3 -c "import sys,json; json.load(sys.stdin)" 2>/dev/null; then
+    check "title" "$json" "title" "str"
+    check "image (URL)" "$json" "image" "str"
+    check "synopsis" "$json" "synopsis" "str"
+    check "type" "$json" "type" "str"
+    check "episodes (str)" "$json" "episodes" "str"
+    check "status" "$json" "status" "str"
+    check "season" "$json" "season" "str"
+    check "studio" "$json" "studio" "str"
+    check "ids.animepahe_id" "$json" "ids.animepahe_id" "str"
+    check "ids.mal" "$json" "ids.mal" "str"
+    check "ids.anilist" "$json" "ids.anilist" "str"
+fi
+echo ""
+
+# ────────────────────────────────────────────────────────────
+echo -e "${CYAN}[8/13] GET /:id/releases (Episodes) (Episodes)${NC}"
+json=$(status_check "Episodes (Naruto)" "$BASE/$ANIME_ID/releases" "200")
+echo ""
+if echo "$json" | python3 -c "import sys,json; json.load(sys.stdin)" 2>/dev/null; then
+    check "paginationInfo.total" "$json" "paginationInfo.total" "int"
+    check "paginationInfo.perPage" "$json" "paginationInfo.perPage" "int"
+    check "paginationInfo.lastPage" "$json" "paginationInfo.lastPage" "int"
+    check "data (array)" "$json" "data" "list"
+    check "data[0].id" "$json" "data.0.id" "int"
+    check "data[0].episode" "$json" "data.0.episode" "int"
+    check "data[0].audio" "$json" "data.0.audio" "str"
+    check "data[0].duration" "$json" "data.0.duration" "str"
+    check "data[0].session" "$json" "data.0.session" "str"
+fi
+echo ""
+
+# ────────────────────────────────────────────────────────────
+echo -e "${CYAN}[9/13] GET /:id/releases (sorted)?sort=&page=2${NC}"
+EP_ID="9a11cba2022e39f2531d2d885a89558263c6a54bb07bb5fb46ef48a5b7e24c82"
+json=$(status_check "Episodes (sorted + paged)" "$BASE/$ANIME_ID/releases?sort=episode_desc&page=2" "200")
+echo ""
+if echo "$json" | python3 -c "import sys,json; json.load(sys.stdin)" 2>/dev/null; then
+    check "paginationInfo.currentPage" "$json" "paginationInfo.currentPage" "int"
+    check "data (array)" "$json" "data" "list"
+fi
+echo ""
+
+# ────────────────────────────────────────────────────────────
+echo -e "${CYAN}[10/13] GET /:id/:ep (Stream + Downloads)${NC}"
+json=$(status_check "Play (Naruto Ep 220)" "$BASE/$ANIME_ID/$EP_ID" "200" "120")
+echo ""
+if echo "$json" | python3 -c "import sys,json; json.load(sys.stdin)" 2>/dev/null; then
+    check "provider" "$json" "provider" "str"
+    check "episode" "$json" "episode" "str"
+    check "anime_title" "$json" "anime_title" "str"
+    check "sources (array)" "$json" "sources" "list"
+    check "sources[0].url (m3u8)" "$json" "sources.0.url" "str"
+    check "sources[0].isM3U8" "$json" "sources.0.isM3U8" "bool"
+    check "sources[0].embed (URL)" "$json" "sources.0.embed" "str"
+    check "sources[0].resolution (str)" "$json" "sources.0.resolution" "str"
+    check "sources[0].download (URL)" "$json" "sources.0.download" "str"
+    check "downloads (array)" "$json" "downloads" "list"
+    check "downloads[0].fansub" "$json" "downloads.0.fansub" "str"
+    check "downloads[0].quality" "$json" "downloads.0.quality" "str"
+    check "downloads[0].filesize" "$json" "downloads.0.filesize" "str"
+    check "downloads[0].isDub" "$json" "downloads.0.isDub" "bool"
+    check "downloads[0].pahe (URL)" "$json" "downloads.0.pahe" "str"
+    check "downloads[0].download (URL)" "$json" "downloads.0.download" "str"
+fi
+echo ""
+
+# ────────────────────────────────────────────────────────────
+echo -e "${CYAN}[11/13] GET /:id/:ep?downloads=false (Stream Only)${NC}"
+json=$(status_check "Play (stream only)" "$BASE/$ANIME_ID/$EP_ID?downloads=false" "200" "60")
+echo ""
+if echo "$json" | python3 -c "import sys,json; json.load(sys.stdin)" 2>/dev/null; then
+    check "sources (array)" "$json" "sources" "list"
+    check "downloads (empty)" "$json" "downloads" "list"
+fi
+echo ""
+
+# ────────────────────────────────────────────────────────────
+echo -e "${CYAN}[12/13] GET /download-links?url= (DEPRECATED)${NC}"
+json=$(status_check "Download links (deprecated)" "$BASE/download-links?url=https://pahe.win/ecJzv" "200" "60")
+echo ""
+if echo "$json" | python3 -c "import sys,json; json.load(sys.stdin)" 2>/dev/null; then
+    check "status" "$json" "status" "int"
+    check "message (deprecated)" "$json" "message" "str"
+fi
+echo ""
+
+# ────────────────────────────────────────────────────────────
+echo -e "${CYAN}[13/13] GET /queue${NC}"
+json=$(status_check "Queue" "$BASE/queue" "200")
+echo ""
+if echo "$json" | python3 -c "import sys,json; json.load(sys.stdin)" 2>/dev/null; then
+    check "data (array)" "$json" "data" "list"
+fi
+echo ""
+
+# ────────────────────────────────────────────────────────────
+echo -e "${CYAN}============================================${NC}"
+echo -e "${GREEN}PASSED: $PASS${NC} | ${RED}FAILED: $FAIL${NC} | ${YELLOW}WARNINGS: $WARN${NC}"
+echo -e "${CYAN}============================================${NC}"
+
+if [[ $FAIL -gt 0 ]]; then
+    exit 1
+fi
+exit 0

package/anime/utils/browser.js

@@ -0,0 +1,172 @@
+const fs = require('fs/promises');
+const path = require('path');
+const { existsSync } = require('fs');
+const os = require('os');
+
+function resolveBrowserRuntime() {
+    let chromiumBinary = null;
+    let chromium = null;
+    let useServerlessChromium = false;
+
+    if (String(process.env.USE_STEALTH).toLowerCase() === 'true') {
+        try {
+            const playwrightExtra = require('playwright-extra');
+            const stealth = require('playwright-extra-plugin-stealth')();
+            chromium = playwrightExtra.chromium;
+            chromium.use(stealth);
+            console.log('Using playwright-extra with stealth plugin (USE_STEALTH=true)');
+        } catch (err) {
+            console.warn('USE_STEALTH=true but playwright-extra or stealth plugin not installed; falling back to regular browser runtime');
+        }
+    }
+
+    try {
+        if (!chromium) {
+            chromiumBinary = require('@sparticuz/chromium');
+            chromium = require('playwright-core').chromium;
+        }
+
+        if (os.platform() === 'linux') {
+            useServerlessChromium = true;
+        } else {
+            console.warn('⚠️ Detected non-Linux OS. Disabling @sparticuz/chromium for local dev.');
+        }
+    } catch (e) {
+        if (!chromium) {
+            try {
+                chromium = require('playwright').chromium;
+                console.warn('Falling back to full Playwright (probably running locally)');
+            } catch (inner) {
+                const error = new Error(
+                    'Browser runtime is not installed. Set FLARESOLVERR_URL or reinstall the Playwright browser stack.'
+                );
+                error.cause = inner;
+                throw error;
+            }
+        }
+    }
+
+    return { chromium, chromiumBinary, useServerlessChromium };
+}
+
+/**
+ * Launches a Chromium browser with appropriate settings for the current environment.
+ * Automatically supports both serverless and local development.
+ */
+async function launchBrowser() {
+    const { chromium, chromiumBinary, useServerlessChromium } = resolveBrowserRuntime();
+    const isServerless = process.env.VERCEL || process.env.NETLIFY || process.env.AWS_LAMBDA_FUNCTION_NAME;
+    const isContainerizedLinux =
+        os.platform() === 'linux' &&
+        (
+            process.env.CONTAINER === 'true' ||
+            process.env.DOCKER === 'true' ||
+            process.env.KUBERNETES_SERVICE_HOST ||
+            existsSync('/.dockerenv')
+        );
+    
+    const baseArgs = [
+        '--no-sandbox',
+        '--disable-setuid-sandbox',
+        '--disable-dev-shm-usage',
+        '--disable-blink-features=AutomationControlled',
+        '--disable-gpu',
+        '--disable-background-networking',
+        '--disable-default-apps',
+        '--disable-extensions',
+        '--disable-infobars',
+        '--disable-notifications',
+        '--disable-offline-sync',
+        '--disable-sync',
+        '--disable-translate',
+        '--no-first-run',
+        '--no-zygote'
+    ];
+
+    // Serverless-specific optimizations
+    const serverlessArgs = [
+        '--disable-background-timer-throttling',
+        '--disable-backgrounding-occluded-windows',
+        '--disable-renderer-backgrounding',
+        '--disable-features=TranslateUI',
+        '--disable-ipc-flooding-protection',
+        '--disable-hang-monitor',
+        '--disable-prompt-on-repost',
+        '--disable-domain-reliability',
+        '--disable-component-extensions-with-background-pages',
+        '--memory-pressure-off',
+        '--max_old_space_size=4096'
+    ];
+
+    // Default headless behavior:
+    // - in serverless environments we want headless=true unless explicitly overridden
+    // - allow overriding with CHROME_HEADLESS env var ("true"/"false") for local testing
+    const envHeadless = typeof process.env.CHROME_HEADLESS !== 'undefined'
+        ? String(process.env.CHROME_HEADLESS).toLowerCase() === 'true'
+        : null;
+
+    // Containers usually do not have a usable display server, so default to headless there too.
+    const defaultHeadless = isServerless || isContainerizedLinux ? true : false;
+
+    const launchOptions = {
+        headless: envHeadless === null ? defaultHeadless : envHeadless,
+        args: isServerless ? [...baseArgs, ...serverlessArgs] : baseArgs,
+        // Reduced timeouts for serverless
+        timeout: isServerless ? 30000 : 60000
+    };
+
+    // Add user agent
+    launchOptions.args.push(
+        '--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+    );
+
+    if (useServerlessChromium && chromiumBinary) {
+        console.log('Using serverless Chromium binary');
+        
+        try {
+            const executablePath = await chromiumBinary.executablePath();
+
+            if (existsSync(executablePath)) {
+                launchOptions.executablePath = executablePath;
+                // Use chromium.args but merge with our custom args
+                // Prepend serverless chromium recommended args so they run first
+                launchOptions.args = [...chromiumBinary.args, ...launchOptions.args];
+                
+                console.log('Serverless Chromium configured successfully');
+            } else {
+                console.warn('⚠️ Chromium binary not found at expected path. Falling back to default.');
+            }
+        } catch (error) {
+            console.error('Error setting up serverless Chromium:', error);
+        }
+    }
+
+    console.log('Launching browser with headless=%s and args count=%d', launchOptions.headless, launchOptions.args.length);
+    
+    try {
+        const browser = await chromium.launch(launchOptions);
+        console.log('Browser launched successfully');
+        return browser;
+    } catch (error) {
+        console.error('Failed to launch browser:', error);
+        
+        // Fallback with minimal args
+        console.log('Attempting fallback launch with minimal configuration...');
+        const fallbackOptions = {
+            headless: true,
+            args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage']
+        };
+        
+        if (useServerlessChromium && chromiumBinary) {
+            try {
+                fallbackOptions.executablePath = await chromiumBinary.executablePath();
+            } catch (e) {
+                console.warn('Could not set executable path for fallback');
+            }
+        }
+        
+        return await chromium.launch(fallbackOptions);
+    }
+}
+
+module.exports = { launchBrowser };

package/anime/utils/config.js

@@ -0,0 +1,209 @@
+const path = require("path");
+const fs = require("fs");
+const dotenv = require("dotenv");
+
+dotenv.config({
+  path: path.join(__dirname, "..", "..", ".env"),
+});
+
+class Config {
+  constructor() {
+    this.hostUrl = "";
+    this.baseUrl = "https://animepahe.pw";
+    this.iframeBaseUrl = "uwucdn.top";
+    this.userAgent =
+      "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+    this.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",
+    };
+    this.cfClearance = "";
+    this.cookiesRefreshInterval = 14 * 24 * 60 * 60 * 1000;
+    this.proxies = [];
+    this.proxyEnabled = false;
+
+    // Environment-specific settings
+    this.isServerless = !!(
+      process.env.VERCEL ||
+      process.env.NETLIFY ||
+      process.env.AWS_LAMBDA_FUNCTION_NAME
+    );
+    this.maxRetries = this.isServerless ? 1 : 3; // Reduced retries on Vercel
+    this.requestTimeout = this.isServerless ? 10000 : 30000; // Reduced timeout on Vercel
+    this.challengeTimeout = this.isServerless ? 10000 : 30000; // Reduced timeout on Vercel
+  }
+
+  setHostUrl(protocol, host) {
+    if (!this.hostUrl && protocol && host) {
+      this.hostUrl = `${protocol}://${host}`;
+      console.log(`Host URL set to: ${this.hostUrl}`);
+    }
+  }
+
+  setCfClearance(value) {
+    if (!value) {
+      console.warn("Warning: cf_clearance value is empty");
+      return false;
+    }
+    this.cfClearance = value.replace(/^cf_clearance=/, "");
+    console.log("\x1b[36m%s\x1b[0m", "cf_clearance set");
+    return true;
+  }
+
+  setCookies(cookieString) {
+    if (!cookieString) return false;
+    const match = cookieString.match(/cf_clearance=([^;]+)/);
+    if (match) {
+      this.cfClearance = match[1];
+      return true;
+    }
+    return false;
+  }
+
+  get cookies() {
+    return this.cfClearance ? `cf_clearance=${this.cfClearance}` : "";
+  }
+
+  setProxy(proxyString) {
+    if (!proxyString) {
+      console.warn("Warning: Proxy string is empty");
+      return false;
+    }
+
+    try {
+      // Validate proxy format (basic check)
+      const proxyUrl = new URL(
+        proxyString.startsWith("http") ? proxyString : `http://${proxyString}`,
+      );
+      if (proxyUrl.hostname) {
+        return true;
+      }
+      return false;
+    } catch (error) {
+      console.warn(`Invalid proxy format: ${proxyString}`);
+      return false;
+    }
+  }
+
+  getRandomProxy() {
+    if (this.proxies.length === 0) {
+      console.log("No proxies available.");
+    }
+    return this.proxies[Math.floor(Math.random() * this.proxies.length)];
+  }
+
+  // Method to update proxies dynamically
+  updateProxies(newProxies) {
+    this.proxies = newProxies;
+  }
+
+  getUrl(section, params = {}) {
+    const { page, tab, genre } = params;
+    const primary = params.primary || params.animeId || params.id || "";
+    const secondary = params.secondary || params.episodeId || params.ep || "";
+
+    const paths = {
+      home: "/",
+      queue: "/queue",
+      animeInfo: `/anime/${primary}`,
+      animeList: "/anime",
+      play: `/play/${primary}/${secondary}`,
+    };
+
+    if (!paths[section]) {
+      throw new Error(`Invalid section: ${section}`);
+    }
+
+    let url = `${this.baseUrl}${paths[section]}`;
+
+    // Add query params for animeList
+    if (section === "animeList") {
+      const queryParams = new URLSearchParams();
+      if (page) queryParams.append("page", page);
+      if (tab) queryParams.append("tab", tab);
+      if (genre) queryParams.append("genre", genre);
+
+      const queryString = queryParams.toString();
+      if (queryString) {
+        url += `?${queryString}`;
+      }
+    }
+
+    return url;
+  }
+
+  loadFromEnv() {
+    if (process.env.BASE_URL) {
+      this.baseUrl = process.env.BASE_URL;
+    }
+
+    if (process.env.USER_AGENT) {
+      this.userAgent = process.env.USER_AGENT;
+    }
+
+    if (process.env.HOST_URL) {
+      this.hostUrl = process.env.HOST_URL;
+    }
+
+    if (process.env.cookiesRefreshInterval) {
+      this.cookiesRefreshInterval = process.env.cookiesRefreshInterval;
+    }
+
+    // Handle cf_clearance
+    if (process.env.CF_CLEARANCE) {
+      this.setCfClearance(process.env.CF_CLEARANCE);
+    }
+
+    // Handle proxies
+    if (process.env.PROXIES) {
+      try {
+        const proxyList = process.env.PROXIES.split(",").map((proxy) =>
+          proxy.trim(),
+        );
+        const validProxies = proxyList.filter((proxy) => this.setProxy(proxy));
+
+        if (validProxies.length === 0) {
+          console.warn("No valid proxies found in environment variables");
+          this.proxies = [];
+        } else {
+          this.proxies = validProxies;
+          console.log(`Successfully loaded ${validProxies.length} proxies`);
+        }
+      } catch (error) {
+        console.error(
+          "Error processing proxies from environment variables:",
+          error.message,
+        );
+        this.proxies = [];
+      }
+    }
+
+    if (process.env.IFRAME_BASE_URL) {
+      this.iframeBaseUrl = process.env.IFRAME_BASE_URL;
+    }
+
+    this.proxyEnabled = process.env.USE_PROXY === "true";
+    if (this.proxyEnabled && this.proxies.length === 0) {
+      console.warn(
+        "Proxy usage is enabled but no valid proxies are configured",
+      );
+    }
+  }
+
+  validate() {
+    if (!this.baseUrl) {
+      throw new Error("Base URL is required in configuration.");
+    }
+    if (!this.userAgent) {
+      throw new Error("User-Agent is required in configuration.");
+    }
+  }
+}
+
+const config = new Config();
+module.exports = config;