update

index.js

@@ -1,272 +1,165 @@
-const express = require('express')
-const { connect } = require("puppeteer-real-browser")
-const fs = require("fs")
-const path = require("path")
+const express = require('express');
+const { connect } = require("puppeteer-real-browser");
+const fs = require('fs');
+const path = require('path');
 
-const app = express()
-const port = process.env.PORT || 7860
-const authToken = process.env.authToken || null
-const DOMAIN = 'https://rezaharis-cf.hf.space' // DOMAINNYA DI SINI
+const app = express();
+const port = process.env.PORT || 7860;
+const authToken = process.env.authToken || null;
+const domain = process.env.DOMAIN || `https://rezaharis-cf.hf.space`; // VARIABEL DOMAIN DI SINI
 
-global.browserLimit = Number(process.env.browserLimit) || 20
-global.timeOut = Number(process.env.timeOut) || 60000
+global.browserLimit = Number(process.env.browserLimit) || 20;
+global.timeOut = Number(process.env.timeOut) || 60000;
 
-const CACHE_DIR = path.join(__dirname, "cache")
-const CACHE_FILE = path.join(CACHE_DIR, "cache.json")
-const CACHE_TTL = 5 * 60 * 1000 
+const CACHE_DIR = path.join(__dirname, "cache");
+const CACHE_FILE = path.join(CACHE_DIR, "cache.json");
+const CACHE_TTL = 5 * 60 * 1000;
 
 function loadCache() {
-  if (!fs.existsSync(CACHE_FILE)) return {}
+  if (!fs.existsSync(CACHE_FILE)) return {};
   try {
-    return JSON.parse(fs.readFileSync(CACHE_FILE, "utf-8"))
+    return JSON.parse(fs.readFileSync(CACHE_FILE, 'utf-8'));
   } catch {
-    return {}
+    return {};
   }
 }
 
 function saveCache(cache) {
   if (!fs.existsSync(CACHE_DIR)) {
-    fs.mkdirSync(CACHE_DIR, { recursive: true })
+    fs.mkdirSync(CACHE_DIR, { recursive: true });
   }
-  fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2), "utf-8")
+  fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2), 'utf-8');
 }
 
 function readCache(key) {
-  const cache = loadCache()
-  const entry = cache[key]
+  const cache = loadCache();
+  const entry = cache[key];
   if (entry && Date.now() - entry.timestamp < CACHE_TTL) {
-    return entry.value
+    return entry.value;
   }
-  return null
+  return null;
 }
 
 function writeCache(key, value) {
-  const cache = loadCache()
-  cache[key] = { timestamp: Date.now(), value }
-  saveCache(cache)
+  const cache = loadCache();
+  cache[key] = { timestamp: Date.now(), value };
+  saveCache(cache);
 }
 
-app.use(express.json())
-app.use(express.urlencoded({ extended: true }))
-
-// Middleware untuk auth token
-app.use((req, res, next) => {
-  if (authToken && req.path !== '/health' && req.path !== '/') {
-    const token = req.body.authToken || req.query.authToken
-    if (token !== authToken) {
-      return res.status(401).json({ message: 'Unauthorized' })
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+// ROUTE UTAMA APP.GET("/")
+app.get("/", (req, res) => {
+  res.json({
+    message: "Server is running!",
+    domain: domain,
+    endpoints: {
+      cloudflare: `${domain}/cloudflare`,
+      turnstile: `${domain}/cloudflare` // via POST ke /cloudflare dengan mode turnstile
+    },
+    status: {
+      browserLimit: global.browserLimit,
+      timeOut: global.timeOut
     }
-  }
-  next()
-})
-
-// Root endpoint
-app.get('/', (req, res) => {
-  res.status(200).json({ 
-    message: 'Cloudflare Solver API',
-    status: 'active',
-    domain: DOMAIN, // TAMPILKAN DOMAIN DI RESPONSE
-    endpoints: ['/cloudflare', '/turnstile', '/health', '/info']
-  })
-})
-
-// Health check endpoint
-app.get('/health', (req, res) => {
-  res.status(200).json({ 
-    status: 'OK', 
-    browserLimit: global.browserLimit,
-    domain: DOMAIN,
-    timestamp: new Date().toISOString()
-  })
-})
-
-// Info endpoint
-app.get('/info', (req, res) => {
-  res.status(200).json({
-    browserLimit: global.browserLimit,
-    timeOut: global.timeOut,
-    domain: DOMAIN,
-    cacheEnabled: true,
-    cacheTTL: CACHE_TTL
-  })
-})
+  });
+});
 
 if (process.env.NODE_ENV !== 'development') {
-  let server = app.listen(port, '0.0.0.0', () => {
-    console.log(`Server running on port ${port}`)
-    console.log(`Domain: ${DOMAIN}`)
-  })
+  let server = app.listen(port, () => {
+    console.log(`Server running on port ${port}`);
+    console.log(`Domain: ${domain}`);
+  });
   try {
-    server.timeout = global.timeOut
-    server.keepAliveTimeout = 60000
+    server.timeout = global.timeOut;
   } catch {}
 }
 
-async function createBrowser(proxyServer = null, proxyAuth = null) {
+async function createBrowser(proxyServer = null) {
   const connectOptions = {
-    headless: true,
+    headless: false,
     turnstile: true,
-    connectOption: { 
-      defaultViewport: null,
-      args: [
-        '--no-sandbox',
-        '--disable-setuid-sandbox',
-        '--disable-dev-shm-usage',
-        '--disable-accelerated-2d-canvas',
-        '--no-first-run',
-        '--no-zygote',
-        '--disable-gpu',
-        '--disable-web-security',
-        '--disable-features=site-per-process',
-        '--disable-blink-features=AutomationControlled'
-      ]
-    },
-    disableXvfb: true,
-  }
-  
-  if (proxyServer) {
-    connectOptions.connectOption.args.push(`--proxy-server=${proxyServer}`)
-  }
-  
-  const { browser } = await connect(connectOptions)
+    connectOption: { defaultViewport: null },
+    disableXvfb: false,
+  };
+  if (proxyServer) connectOptions.args = [`--proxy-server=${proxyServer}`];
 
-  // Set stealth
-  const pages = await browser.pages()
-  const page = pages[0]
+  const { browser } = await connect(connectOptions);
+  const [page] = await browser.pages();
 
-  // Remove webdriver property
-  await page.evaluateOnNewDocument(() => {
-    Object.defineProperty(navigator, 'webdriver', {
-      get: () => undefined,
-    })
-  })
-
-  await page.setRequestInterception(true)
+  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()
-    }
-  })
+    const type = req.resourceType();
+    if (["image", "stylesheet", "font", "media"].includes(type)) req.abort();
+    else req.continue();
+  });
 
-  return { browser, page }
+  return { browser, page };
 }
 
-// Import endpoints
-const turnstile = require('./endpoints/turnstile')
-const cloudflare = require('./endpoints/cloudflare')
+const turnstile = require('./endpoints/turnstile');
+const cloudflare = require('./endpoints/cloudflare');
 
-// ENDPOINT CLOUDFLARE - GUNAKAN DOMAIN YANG SUDAH DIATUR
 app.post('/cloudflare', async (req, res) => {
-  const data = req.body
-  if (!data) {
-    return res.status(400).json({ message: 'Bad Request: missing data' })
+  const data = req.body;
+  if (!data || typeof data.mode !== 'string')
+    return res.status(400).json({ message: 'Bad Request: missing or invalid mode' });
+  if (authToken && data.authToken !== authToken)
+    return res.status(401).json({ message: 'Unauthorized' });
+
+  if (global.browserLimit <= 0)
+    return res.status(429).json({ message: 'Too Many Requests' });
+
+  let cacheKey, cached;
+  if (data.mode === "iuam") {
+    cacheKey = JSON.stringify(data);
+    cached = readCache(cacheKey);
+    if (cached) return res.status(200).json({ ...cached, cached: true });
   }
 
-  // Gunakan domain dari request atau domain default
-  const domain = data.domain || DOMAIN
-
-  if (global.browserLimit <= 0) {
-    return res.status(429).json({ message: 'Too Many Requests: browser limit reached' })
-  }
-
-  // Check cache
-  const cacheKey = JSON.stringify({...data, domain})
-  const cached = readCache(cacheKey)
-  if (cached) {
-    return res.status(200).json({ ...cached, cached: true })
-  }
-
-  global.browserLimit--
-  let result
-  let browser, page
+  global.browserLimit--;
+  let result, browser;
 
   try {
-    const proxyServer = data.proxy ? `${data.proxy.hostname}:${data.proxy.port}` : null
-    const ctx = await createBrowser(proxyServer, data.proxy)
-    browser = ctx.browser
-    page = ctx.page
-
-    // Pass domain ke fungsi cloudflare
-    result = await cloudflare({...data, domain}, page)
-
-    if (result.cf_clearance) {
-      writeCache(cacheKey, result)
+    const proxyServer = data.proxy ? `${data.proxy.hostname}:${data.proxy.port}` : null;
+    const ctx = await createBrowser(proxyServer);
+    browser = ctx.browser;
+    const page = ctx.page;
+
+    await page.goto('about:blank');
+
+    switch (data.mode) {
+      case "turnstile":
+        result = await turnstile(data, page)
+          .then(token => ({ token }))
+          .catch(err => ({ code: 500, message: err.message }));
+        break;
+
+      case "iuam":
+        result = await cloudflare(data, page)
+          .then(r => ({ ...r }))
+          .catch(err => ({ code: 500, message: err.message }));
+        if (!result.code || result.code === 200) writeCache(cacheKey, result);
+        break;
+
+      default:
+        result = { code: 400, message: 'Invalid mode' };
     }
-
-  } catch (err) {
-    result = { 
-      cf_clearance: null, 
-      user_agent: null,
-      elapsed_time: 0,
-      error: err.message 
-    }
-  } finally {
-    if (browser) {
-      try { 
-        await browser.close() 
-      } catch (err) {
-        console.error('Error closing browser:', err.message)
-      }
-    }
-    global.browserLimit++
-  }
-
-  res.status(200).json(result)
-})
-
-// Endpoint khusus untuk Turnstile
-app.post('/turnstile', async (req, res) => {
-  const data = req.body
-  if (!data || !data.sitekey || !data.url) {
-    return res.status(400).json({ message: 'Bad Request: missing sitekey or url' })
-  }
-
-  if (global.browserLimit <= 0) {
-    return res.status(429).json({ message: 'Too Many Requests: browser limit reached' })
-  }
-
-  global.browserLimit--
-  let result
-  let browser, page
-
-  try {
-    const proxyServer = data.proxy ? `${data.proxy.hostname}:${data.proxy.port}` : null
-    const ctx = await createBrowser(proxyServer, data.proxy)
-    browser = ctx.browser
-    page = ctx.page
-
-    const token = await turnstile(data, page)
-    result = { token }
-
   } catch (err) {
-    result = { error: err.message }
+    result = { code: 500, message: err.message };
   } finally {
-    if (browser) {
-      try { 
-        await browser.close() 
-      } catch (err) {
-        console.error('Error closing browser:', err.message)
-      }
-    }
-    global.browserLimit++
+    if (browser) try { await browser.close(); } catch {}
+    global.browserLimit++;
   }
 
-  res.status(200).json(result)
-})
+  res.status(result.code ?? 200).json(result);
+});
 
 app.use((req, res) => {
-  res.status(404).json({ message: 'Not Found' })
-})
-
-// Error handling middleware
-app.use((err, req, res, next) => {
-  console.error('Server Error:', err)
-  res.status(500).json({ message: 'Internal Server Error' })
-})
+  res.status(404).json({ message: 'Not Found' });
+});
 
 if (process.env.NODE_ENV === 'development') {
-  module.exports = app
+  module.exports = app;
 }