Update Api.js

Api.js

@@ -1,224 +1,180 @@
 /**
- * API.js
+ * API.js - Optimized for Hugging Face Docker
+ * Powered by Gemini
  */
 const express = require('express');
 const { connect } = require("puppeteer-real-browser");
 const fs = require('fs');
 const path = require('path');
 
+// Import Solver Modules ti awal sangkan kadefinisikeun
+const turnstile = require('./Api/turnstile');
+const interstitial = require('./Api/interstitial');
+const recaptchaV2 = require('./Api/recaptcha2');
+const recaptchaV3 = require('./Api/recaptcha3');
+
 const app = express();
 const port = process.env.PORT || 7860;
-const authToken = process.env.authToken || null; // set in env/secrets
+const authToken = process.env.authToken || null;
 
 global.browserLimit = 100;
 global.timeOut = 300000;
 
-// cache 
+// Cache Configuration
 const CACHE_DIR = path.join(__dirname, "cache");
-const CACHE_FILE = path.join(CACHE_DIR, "cache.json");
 const CACHE_TTL = 5 * 60 * 1000;
 const CACHE_AUTOSAVE = process.env.CACHE_AUTOSAVE === "true";
 
-function readCache(type, taskId) {
-    const file = path.join(CACHE_DIR, type, `${taskId}.json`);
-    if (!fs.existsSync(file)) return null;
-
-    try {
-        const data = JSON.parse(fs.readFileSync(file, 'utf-8'));
-        console.log(`cache check: ${type}:${taskId} => ${data ? "HIT" : "MISS"}`);
-        if (Date.now() - data.timestamp < CACHE_TTL) {
-            return data;
-        }
-        return null;
-    } catch {
-        return null;
-    }
-}
+if (!fs.existsSync(CACHE_DIR)) fs.mkdirSync(CACHE_DIR, { recursive: true });
 
 function writeCache(type, taskId, value) {
     const dir = path.join(CACHE_DIR, type);
     if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-
     const file = path.join(dir, `${taskId}.json`);
     const data = { timestamp: Date.now(), ...value };
-
     fs.writeFileSync(file, JSON.stringify(data, null, 2), 'utf-8');
-    console.log(`cache saved: ${type}:${taskId}`);
 }
 
 function cleanCache() {
     const types = ["turnstile", "recaptcha3", "recaptcha2", "interstitial", "error"];
     const now = Date.now();
-    const TTL = 60 * 60 * 1000;
-
     types.forEach(type => {
         const dir = path.join(CACHE_DIR, type);
-        if (!fs.existsSync(dir)) return;
-
-        fs.readdirSync(dir).forEach(file => {
-            const filePath = path.join(dir, file);
-            try {
-                const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-                if (now - data.timestamp > TTL) {
-                    fs.unlinkSync(filePath);
-                    console.log(`cache expired: ${filePath}`);
-                }
-            } catch {
-                fs.unlinkSync(filePath);
-            }
-        });
+        if (fs.existsSync(dir)) {
+            fs.readdirSync(dir).forEach(file => {
+                const filePath = path.join(dir, file);
+                try {
+                    const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                    if (now - data.timestamp > 3600000) fs.unlinkSync(filePath);
+                } catch (e) { fs.unlinkSync(filePath); }
+            });
+        }
     });
 }
-
 setInterval(cleanCache, 600 * 1000);
 
 app.use(express.json());
 app.use(express.urlencoded({ extended: true }));
+
 const tasks = {};
 
-/**
- * Authorization middleware
- * - If authToken is not set on server, middleware allows requests (convenience for dev).
- * - If authToken is set, requires either:
- *    Authorization: Bearer <token>
- *    OR header: key: <token>
- */
+// Authorization Middleware
 app.use((req, res, next) => {
-    if (!authToken) return next(); // no token configured => allow
-
-    const authHdr = (req.get('Authorization') || req.get('authorization') || '').trim();
-    const bearer = authHdr.startsWith('Bearer ') ? authHdr.slice(7).trim() : authHdr;
-    const keyHeader = (req.get('key') || req.get('Key') || '').trim();
-
-    if (bearer === authToken || keyHeader === authToken) return next();
-
+    if (!authToken) return next();
+    const authHdr = (req.get('Authorization') || req.get('key') || '').replace('Bearer ', '').trim();
+    if (authHdr === authToken) return next();
     res.status(401).json({ status: "error", message: "Unauthorized" });
 });
 
-// Api_route
+// Root Route
 app.get("/", (req, res) => {
-    const baseUrl = `${req.protocol}://${req.get('host')}`;
-    const uptime = process.uptime(); 
     res.json({
-        message: "Welcome",
-        server: {
-            domain: baseUrl,
-            version: "7.3.0",
-            uptime: `${Math.floor(uptime)} seconds`,
-            limit: global.browserLimit,
-            timeout: global.timeOut,
-            status: "recently running"
-        },
+        status: "online",
+        version: "7.3.0",
         solvers: ["turnstile", "recaptcha2", "recaptcha3", "interstitial"]
     });
 });
 
+/**
+ * init_browser - Optimized for Docker/HuggingFace
+ */
+async function init_browser(proxyServer = null) {
+    const connectOptions = {
+        headless: false, // Wajib false mun make puppeteer-real-browser + Xvfb
+        turnstile: true,
+        connectOption: { 
+            defaultViewport: null,
+            args: [
+                '--no-sandbox', 
+                '--disable-setuid-sandbox', 
+                '--disable-dev-shm-usage', // Krusial pikeun Docker
+                '--disable-gpu',
+                '--no-zygote',
+                '--single-process'
+            ]
+        },
+        disableXvfb: false, 
+    };
+
+    if (proxyServer) {
+        connectOptions.connectOption.args.push(`--proxy-server=${proxyServer}`);
+    }
+
+    const { browser } = await connect(connectOptions);
+    const [page] = await browser.pages();
+
+    // Set simple interception pikeun ngahemat resource
+    await page.setRequestInterception(true);
+    page.on('request', (req) => {
+        if (["image", "font", "media"].includes(req.resourceType())) req.abort();
+        else req.continue();
+    });
+
+    return { browser, page };
+}
+
+
 
 app.post('/solve', async (req, res) => {
     const { type, domain, siteKey, taskId, action, proxy, isInvisible } = req.body;
 
+    // Check Task Status
     if (taskId) {
         const task = tasks[taskId];
         if (!task) return res.status(404).json({ status: "error", message: "Task not found" });
-
-        if (task.status === "pending") {
-            return res.json({ status: "processing" });
-        }
-
         return res.json(task);
     }
 
     const newTaskId = Date.now().toString(36);
     tasks[newTaskId] = { status: "pending" };
-    console.log(`New : ${newTaskId}=${type}:${domain}`);
+    console.log(`[New Task] ${newTaskId} | Type: ${type} | Domain: ${domain}`);
 
+    // Async Execution
     (async () => {
+        let ctx = null;
         try {
-            const ctx = await init_browser(proxy?.server);
-            const page = ctx.page;
+            ctx = await init_browser(proxy?.server);
             let result;
 
             switch (type) {
                 case "turnstile":
-                    result = await turnstile({ domain, siteKey, action, proxy }, page);
-                    tasks[newTaskId] = { status: "done", ...result };
-                    console.log(`done: ${newTaskId}=${type}:${domain}`);
-                    if (CACHE_AUTOSAVE) writeCache("turnstile", newTaskId, tasks[newTaskId]);
+                    result = await turnstile({ domain, siteKey, action, proxy }, ctx.page);
                     break;
-
                 case "interstitial":
-                    result = await interstitial({ domain, proxy }, page);
-                    tasks[newTaskId] = { status: "done", ...result };
-                    console.log(`done: ${newTaskId}=${type}:${domain}`);
-                    if (CACHE_AUTOSAVE) writeCache("interstitial", newTaskId, tasks[newTaskId]);
+                    result = await interstitial({ domain, proxy }, ctx.page);
                     break;
-
                 case "recaptcha2":
-                    result = await recaptchaV2({ domain, siteKey, action, isInvisible, proxy }, page);
-                    tasks[newTaskId] = { status: "done", ...result };
-                    console.log(`done: ${newTaskId}=${type}:${domain}`);
-                    if (CACHE_AUTOSAVE) writeCache("recaptcha2", newTaskId, tasks[newTaskId]);
+                    result = await recaptchaV2({ domain, siteKey, action, isInvisible, proxy }, ctx.page);
                     break;
-                    
                 case "recaptcha3":
-                    result = await recaptchaV3({ domain, siteKey, action, proxy }, page);
-                    tasks[newTaskId] = { status: "done", ...result };
-                    console.log(`done: ${newTaskId}=${type}:${domain}`);
-                    if (CACHE_AUTOSAVE) writeCache("recaptcha3", newTaskId, tasks[newTaskId]);
+                    result = await recaptchaV3({ domain, siteKey, action, proxy }, ctx.page);
                     break;
-
                 default:
-                    tasks[newTaskId] = { status: "error", message: "Invalid type" };
+                    throw new Error("Invalid solver type");
             }
 
-            await ctx.browser.close();
-            console.log(`Browser closed ${newTaskId}`);
+            tasks[newTaskId] = { status: "done", ...result };
+            if (CACHE_AUTOSAVE) writeCache(type, newTaskId, tasks[newTaskId]);
+            console.log(`[Success] Task ${newTaskId} completed`);
+
         } catch (err) {
-            tasks[newTaskId] = { status: "error", message: "totally failed" };
-            console.error(`failed: ${newTaskId}=${type}:${domain}`);
-            console.error("Detailed error:", err);
+            tasks[newTaskId] = { status: "error", message: err.message || "Execution failed" };
+            console.error(`[Error] Task ${newTaskId}:`, err.message);
+        } finally {
+            if (ctx && ctx.browser) {
+                await ctx.browser.close().catch(() => {});
+                console.log(`[System] Browser closed for ${newTaskId}`);
+            }
         }
     })();
 
     res.json({ taskId: newTaskId, status: "pending" });
 });
 
-// init_browser
-async function init_browser(proxyServer = null) {
-    const connectOptions = {
-        headless: false,
-        turnstile: true,
-        connectOption: { defaultViewport: null },
-        disableXvfb: false,
-    };
-    if (proxyServer) connectOptions.args = [`--proxy-server=${proxyServer}`];
-
-    const { browser } = await connect(connectOptions);
-    const [page] = await browser.pages();
-
-    await page.goto('about:blank');
-    await page.setRequestInterception(true);
-    page.on('request', (req) => {
-        const type = req.resourceType();
-        if (["image", "stylesheet", "font", "media"].includes(type)) req.abort();
-        else req.continue();
-    });
-    console.log(`initialized${proxyServer ? "proxy= " + proxyServer : ""}`);
-
-    return { browser, page };
-}
-
-
-const turnstile = require('./Api/turnstile');
-const interstitial = require('./Api/interstitial');
-const recaptchaV2 = require('./Api/recaptcha2');
-const recaptchaV3 = require('./Api/recaptcha3');
-
-app.use((req, res) => {
-    res.status(404).json({ message: 'Not Found' });
-    console.warn(`error: ${req.method} ${req.originalUrl}`);
-});
+app.use((req, res) => res.status(404).json({ message: 'Route not found' }));
 
 app.listen(port, () => {
-    console.log(`Server running: http://localhost:${port}`);
-});
+    console.log(`========================================`);
+    console.log(`🚀 Solver API Running on port ${port}`);
+    console.log(`========================================`);
+});