Upload 3 files

endpoints/antibot.js

@@ -0,0 +1,380 @@
+const fs = require('fs');
+const path = require('path');
+const { extractTextFromImage, uploadImageToHosting } = require('./imageProcessor');
+
+async function extractTextFromBuffer(imageBuffer) {
+  try {
+    console.log('🖼️ DEBUG extractTextFromBuffer: Membuat file temporary');
+    const tempPath = path.join(__dirname, `temp_${Date.now()}.jpg`);
+    fs.writeFileSync(tempPath, imageBuffer);
+    console.log('📁 DEBUG: File temporary dibuat:', tempPath);
+    
+    const result = await extractTextFromImage(tempPath);
+    console.log('✅ DEBUG extractTextFromBuffer: Hasil ekstraksi:', result);
+    
+    fs.unlinkSync(tempPath);
+    console.log('🧹 DEBUG: File temporary dihapus');
+    
+    return result;
+  } catch (error) {
+    console.error('❌ DEBUG extractTextFromBuffer Error:', error.message);
+    return { status: false, response: 'Gagal memproses gambar' };
+  }
+}
+
+function mapAnswer(soalArray, jawaban, botIndex) {
+  console.log(`🤖 DEBUG mapAnswer: Bot ${botIndex}, Jawaban: "${jawaban}"`);
+  return jawaban;
+}
+
+function normalizeText(text) {
+  const normalized = text.toLowerCase().replace(/[^\w\s]/g, '').trim();
+  console.log(`🔤 DEBUG normalizeText: "${text}" -> "${normalized}"`);
+  return normalized;
+}
+
+function isValueMatch(value, targetSoal) {
+  console.log(`🔍 DEBUG isValueMatch: Value="${value}", Soal="${targetSoal}"`);
+
+  const numberMap = {
+    '0': 'zero', '1': 'one', '2': 'two', '3': 'three', '4': 'four',
+    '5': 'five', '6': 'six', '7': 'seven', '8': 'eight', '9': 'nine', '10': 'ten',
+    'zero': '0', 'one': '1', 'two': '2', 'three': '3', 'four': '4',
+    'five': '5', 'six': '6', 'seven': '7', 'eight': '8', 'nine': '9', 'ten': '10',
+    'I': '1', 'II': '2', 'III': '3', 'IV': '4', 'V': '5',
+    'VI': '6', 'VII': '7', 'VIII': '8', 'IX': '9', 'X': '10',
+    'slx': '6', 's1x': '6', 'six': '6',
+    'f0ur': '4', 'f0r': '4', 'fuor': '4',
+    'f1ve': '5', 'fiv': '5', 'f1v': '5',
+    'e1ght': '8', 'elght': '8', 'eight': '8',
+    'n1ne': '9', 'n1n': '9', 'nne': '9',
+    'se7en': '7', 'sven': '7', 'seven': '7',
+    'thre': '3', 'tree': '3', 'thr33': '3',
+    'tw0': '2', 'to': '2', 'tw': '2',
+    '0ne': '1', 'on': '1', 'oen': '1'
+  };
+
+  const leetMap = {
+    'O': '0', 'o': '0',
+    'I': '1', 'i': '1', 'l': '1',
+    'Z': '2', 'z': '2',
+    'E': '3', 'e': '3',
+    'A': '4', 'a': '4',
+    'S': '5', 's': '5',
+    'G': '6', 'g': '6',
+    'T': '7', 't': '7',
+    'B': '8', 'b': '8',
+    'Q': '9', 'q': '9',
+    'U': '4', 'u': '4',
+    'R': '2', 'r': '2',
+    'N': '9', 'n': '9',
+    'V': '7', 'v': '7'
+  };
+
+  const normalizedValue = normalizeText(value);
+  const normalizedSoal = normalizeText(targetSoal);
+
+  if (normalizedValue === normalizedSoal) {
+    console.log('✅ DEBUG: Match exact normalized');
+    return true;
+  }
+
+  const convertLeet = (text) => {
+    return text.split('').map(char => leetMap[char] || char).join('');
+  };
+
+  const leetValue = convertLeet(value);
+  const leetSoal = convertLeet(targetSoal);
+
+  console.log(`🔢 DEBUG Leet: Value="${leetValue}", Soal="${leetSoal}"`);
+
+  if (leetValue === normalizedSoal) {
+    console.log('✅ DEBUG: Match leet value -> normalized soal');
+    return true;
+  }
+  if (normalizedValue === leetSoal) {
+    console.log('✅ DEBUG: Match normalized value -> leet soal');
+    return true;
+  }
+  if (leetValue === leetSoal) {
+    console.log('✅ DEBUG: Match leet value -> leet soal');
+    return true;
+  }
+
+  const mappedValue = numberMap[normalizedValue] || numberMap[value] || normalizedValue;
+  const mappedSoal = numberMap[normalizedSoal] || numberMap[targetSoal] || normalizedSoal;
+
+  console.log(`🔄 DEBUG Number Map: Value="${mappedValue}", Soal="${mappedSoal}"`);
+
+  if (mappedValue === normalizedSoal) {
+    console.log('✅ DEBUG: Match mapped value -> normalized soal');
+    return true;
+  }
+  if (normalizedValue === mappedSoal) {
+    console.log('✅ DEBUG: Match normalized value -> mapped soal');
+    return true;
+  }
+  if (mappedValue === mappedSoal) {
+    console.log('✅ DEBUG: Match mapped value -> mapped soal');
+    return true;
+  }
+
+  const similarity = calculateSimilarity(normalizedValue, normalizedSoal);
+  console.log(`📊 DEBUG Similarity: ${similarity}`);
+  if (similarity >= 0.8) {
+    console.log('✅ DEBUG: Match similarity >= 0.8');
+    return true;
+  }
+
+  try {
+    const valueResult = evaluateSimpleMath(value);
+    const soalResult = evaluateSimpleMath(targetSoal);
+    console.log(`🧮 DEBUG Math: Value=${valueResult}, Soal=${soalResult}`);
+    if (valueResult !== null && soalResult !== null && valueResult === soalResult) {
+      console.log('✅ DEBUG: Match math evaluation');
+      return true;
+    }
+  } catch (e) {
+    console.log('❌ DEBUG Math evaluation failed');
+  }
+
+  console.log('❌ DEBUG: No match found');
+  return false;
+}
+
+function calculateSimilarity(str1, str2) {
+  if (str1 === str2) return 1;
+  if (str1.length === 0 || str2.length === 0) return 0;
+  
+  const longer = str1.length > str2.length ? str1 : str2;
+  const shorter = str1.length > str2.length ? str2 : str1;
+  
+  if (longer.includes(shorter)) return shorter.length / longer.length;
+  
+  let matches = 0;
+  for (let i = 0; i < shorter.length; i++) {
+    if (shorter[i] === longer[i]) matches++;
+  }
+  
+  return matches / longer.length;
+}
+
+function evaluateSimpleMath(expression) {
+  if (!expression) return null;
+  const cleanExpr = expression.toString().replace(/[^\d+\-*/.()]/g, '');
+  if (!cleanExpr) return null;
+  try {
+    if (cleanExpr.length > 10) return null;
+    const result = Function(`"use strict"; return (${cleanExpr})`)();
+    return typeof result === 'number' ? result : null;
+  } catch (e) {
+    return null;
+  }
+}
+
+function parseSoalText(text) {
+  console.log(`📝 DEBUG parseSoalText: Input text: "${text}"`);
+  const delimiters = /[.,:;\\/\s]+/;
+  let parts = text.split(delimiters).filter(part => part.trim() !== '');
+  if (parts.length === 1) {
+    parts = text.split(/\s+/).filter(part => part.trim() !== '');
+  }
+  console.log(`📝 DEBUG parseSoalText: Parsed parts:`, parts);
+  return parts;
+}
+
+async function antibot(data) {
+  console.log('🚀 DEBUG antibot: Memulai proses antibot');
+  console.log('📊 DEBUG: Data received - main:', data.main ? '✅' : '❌', 'bots:', data.bots?.length || 0);
+  
+  try {
+    const { main, bots } = data;
+
+    console.log('🖼️ DEBUG: Processing main image...');
+    const mainBuffer = Buffer.from(main, 'base64');
+    const mainText = await extractTextFromBuffer(mainBuffer);
+    
+    console.log('📄 DEBUG Main Text Result:', mainText);
+    
+    if (!mainText.status) {
+      throw new Error('Gagal mengekstrak teks dari gambar utama: ' + mainText.response);
+    }
+
+    const soalArray = parseSoalText(mainText.response);
+    console.log(`📋 DEBUG: Soal array:`, soalArray);
+    
+    if (soalArray.length === 0) {
+      throw new Error('Tidak ada soal yang terdeteksi');
+    }
+
+    const botResults = [];
+    console.log(`🤖 DEBUG: Processing ${bots.length} bots...`);
+    
+    for (let i = 0; i < bots.length; i++) {
+      const bot = bots[i];
+      console.log(`🤖 DEBUG: Processing bot ${i+1}/${bots.length} - ID: ${bot.id}`);
+      try {
+        const botBuffer = Buffer.from(bot.img, 'base64');
+        const botText = await extractTextFromBuffer(botBuffer);
+        const mappedValue = mapAnswer(soalArray, botText.response, i);
+        
+        botResults.push({
+          id: bot.id,
+          text: botText.response,
+          value: mappedValue,
+          normalized: normalizeText(botText.response)
+        });
+        
+        console.log(`✅ DEBUG Bot ${bot.id}:`, {
+          text: botText.response,
+          value: mappedValue,
+          normalized: normalizeText(botText.response)
+        });
+        
+      } catch (error) {
+        console.error(`❌ DEBUG Bot ${bot.id} Error:`, error.message);
+        botResults.push({
+          id: bot.id,
+          text: '',
+          value: '',
+          normalized: '',
+          error: error.message
+        });
+      }
+    }
+
+    console.log('🔍 DEBUG: Starting matching process...');
+    const result = [];
+    const usedIds = new Set();
+    let matchedCount = 0;
+
+    // Step 1: Exact matching dengan soal
+    for (let i = 0; i < soalArray.length; i++) {
+      const targetSoal = soalArray[i];
+      console.log(`🎯 DEBUG: Matching soal "${targetSoal}"`);
+      let foundId = null;
+
+      for (const bot of botResults) {
+        if (!usedIds.has(bot.id) && bot.value && bot.value.trim() !== '' && 
+            isValueMatch(bot.value, targetSoal)) {
+          foundId = bot.id;
+          usedIds.add(bot.id);
+          matchedCount++;
+          console.log(`✅ DEBUG: Soal "${targetSoal}" matched with bot ${bot.id}`);
+          break;
+        }
+      }
+
+      result.push({ 
+        id: foundId,
+        soal: targetSoal,
+        matchType: foundId ? 'exact' : 'none'
+      });
+    }
+
+    console.log(`📊 DEBUG: Initial matches: ${matchedCount}/${soalArray.length}`);
+
+    // Step 2: Jika masih ada soal yang belum dapat match, coba normalized matching
+    if (matchedCount < soalArray.length) {
+      console.log('🔄 DEBUG: Trying normalized matching...');
+      for (let i = 0; i < result.length; i++) {
+        if (!result[i].id) {
+          const targetSoal = soalArray[i];
+          const normalizedSoal = normalizeText(targetSoal);
+          
+          for (const bot of botResults) {
+            if (!usedIds.has(bot.id) && bot.normalized && bot.normalized.trim() !== '') {
+              if (bot.normalized === normalizedSoal) {
+                result[i].id = bot.id;
+                result[i].matchType = 'normalized';
+                usedIds.add(bot.id);
+                matchedCount++;
+                console.log(`✅ DEBUG: Soal "${targetSoal}" normalized match with bot ${bot.id}`);
+                break;
+              }
+            }
+          }
+        }
+      }
+    }
+
+    console.log(`📊 DEBUG: After normalized: ${matchedCount}/${soalArray.length}`);
+
+    // Step 3: Jika masih ada bot yang belum digunakan, assign ke soal yang belum ada jawaban
+    const unusedBots = botResults.filter(bot => !usedIds.has(bot.id) && bot.value && bot.value.trim() !== '');
+    console.log(`🔄 DEBUG: Unused bots: ${unusedBots.length}`);
+    
+    for (let i = 0; i < result.length; i++) {
+      if (!result[i].id && unusedBots.length > 0) {
+        const bot = unusedBots.shift();
+        result[i].id = bot.id;
+        result[i].matchType = 'fallback';
+        usedIds.add(bot.id);
+        console.log(`🔄 DEBUG: Soal ${i+1} fallback to bot ${bot.id}`);
+      }
+    }
+
+    // Step 4: Jika masih ada bot yang belum digunakan, buat result tambahan
+    const remainingBots = botResults.filter(bot => !usedIds.has(bot.id) && bot.value && bot.value.trim() !== '');
+    console.log(`➕ DEBUG: Remaining bots to add: ${remainingBots.length}`);
+    
+    for (const bot of remainingBots) {
+      result.push({
+        id: bot.id,
+        soal: '',
+        matchType: 'extra'
+      });
+      usedIds.add(bot.id);
+      console.log(`➕ DEBUG: Added extra bot ${bot.id} to result`);
+    }
+
+    // Step 5: Handle kasus dimana tidak ada match sama sekali
+    if (result.length === 0) {
+      console.log('❌ DEBUG: No matches found, all invalid');
+      for (let i = 0; i < soalArray.length; i++) {
+        result.push({
+          id: 'invalid',
+          soal: soalArray[i],
+          matchType: 'invalid'
+        });
+      }
+    }
+
+    console.log('🎉 DEBUG: Process completed successfully');
+    console.log('📋 DEBUG Final Result:', result);
+
+    return {
+      success: true,
+      data: {
+        soal: soalArray,
+        soalLeet: soalArray,
+        botResults: botResults,
+        result: result.map(r => ({ id: r.id })),
+        debug: {
+          parsedSoal: soalArray,
+          matches: result.map(r => ({ 
+            id: r.id, 
+            matchType: r.matchType, 
+            soal: r.soal 
+          })),
+          totalMatches: matchedCount,
+          totalResults: result.length
+        }
+      }
+    };
+
+  } catch (error) {
+    console.error('💥 DEBUG antibot Error:', error.message);
+    return {
+      success: false,
+      error: error.message,
+      data: {
+        soal: [],
+        botResults: [],
+        result: []
+      }
+    };
+  }
+}
+
+module.exports = antibot;

endpoints/imageProcessor

@@ -0,0 +1,165 @@
+const fs = require('fs');
+const https = require('https');
+const FormData = require('form-data');
+
+const SESSION_IDS = [
+    "neko-" + Date.now(),
+    "session-" + Math.random().toString(36).substring(2, 15),
+    "bot-" + Math.random().toString(36).substring(2, 10)
+];
+
+function getRandomSessionId() {
+    const sessionId = SESSION_IDS[Math.floor(Math.random() * SESSION_IDS.length)];
+    console.log(`🎲 DEBUG getRandomSessionId: Selected session ID: ${sessionId}`);
+    return sessionId;
+}
+
+async function uploadImageToHosting(imageBuffer) {
+    console.log('📤 DEBUG uploadImageToHosting: Starting image upload');
+    return new Promise((resolve, reject) => {
+        try {
+            const formData = new FormData();
+            const filename = `upload-${Date.now()}.jpg`;
+            formData.append("file", imageBuffer, {
+                filename: filename,
+                contentType: "image/jpeg"
+            });
+
+            console.log(`📁 DEBUG: Uploading file: ${filename}, Size: ${imageBuffer.length} bytes`);
+
+            const options = {
+                hostname: 'fourmovie-uploader.hf.space',
+                path: '/api/upload',
+                method: 'POST',
+                headers: formData.getHeaders()
+            };
+
+            const req = https.request(options, (res) => {
+                let data = '';
+
+                console.log(`📡 DEBUG: Upload response status: ${res.statusCode}`);
+
+                res.on('data', (chunk) => {
+                    data += chunk;
+                });
+
+                res.on('end', () => {
+                    try {
+                        console.log('📄 DEBUG: Upload response received');
+                        const response = JSON.parse(data);
+                        console.log('🔗 DEBUG: Upload response data:', response);
+                        
+                        if (response.file?.url) {
+                            console.log(`✅ DEBUG: Image uploaded successfully, URL: ${response.file.url}`);
+                            resolve(response.file.url);
+                        } else {
+                            console.log('❌ DEBUG: No URL in upload response');
+                            resolve(null);
+                        }
+                    } catch (error) {
+                        console.error('❌ DEBUG: Error parsing upload response:', error);
+                        resolve(null);
+                    }
+                });
+            });
+
+            req.on('error', (error) => {
+                console.error('❌ DEBUG: Upload request error:', error);
+                resolve(null);
+            });
+
+            formData.pipe(req);
+            console.log('🔄 DEBUG: Form data piped to request');
+
+        } catch (error) {
+            console.error('❌ DEBUG: Upload failed:', error);
+            resolve(null);
+        }
+    });
+}
+
+async function extractTextFromImage(imagePath) {
+    console.log(`🖼️ DEBUG extractTextFromImage: Processing image: ${imagePath}`);
+    return new Promise(async (resolve, reject) => {
+        try {
+            console.log('📖 DEBUG: Reading image file...');
+            const imageBuffer = fs.readFileSync(imagePath);
+            console.log(`✅ DEBUG: Image read successfully, size: ${imageBuffer.length} bytes`);
+            
+            console.log('☁️ DEBUG: Uploading image to hosting...');
+            const imageUrl = await uploadImageToHosting(imageBuffer);
+            if (!imageUrl) {
+                console.log('❌ DEBUG: Image upload failed');
+                return resolve({ status: false, response: 'Gagal mengunggah gambar ke hosting' });
+            }
+
+            console.log(`🔗 DEBUG: Image uploaded, URL: ${imageUrl}`);
+            const sessionId = getRandomSessionId();
+
+            const textParam = encodeURIComponent("hi how are you");
+            const systemPrompt = encodeURIComponent("Berikan text yang ada di gambar ini saja, tidak ada informasi lain cukup yang ada di gambar saja, jangan ada text lain kalo bukan dari gambar nya. dan ini adalah pembatas iya _ , : ; dan tolong tiap text berbeda beda kalo ada pembatas itu kirim satu kalimat saja");
+            const imageUrlParam = encodeURIComponent(imageUrl);
+
+            const apiUrl = `https://api.nekolabs.web.id/ai/gemini/2.5-flash/v2?text=${textParam}&systemPrompt=${systemPrompt}&imageUrl=${imageUrlParam}&sessionId=${sessionId}`;
+            console.log(`🌐 DEBUG: API URL constructed (short): https://api.nekolabs.web.id/ai/gemini/2.5-flash/v2?...`);
+
+            const options = {
+                hostname: 'api.nekolabs.web.id',
+                path: `/ai/gemini/2.0-flash/v2?text=${textParam}&systemPrompt=${systemPrompt}&imageUrl=${imageUrlParam}&sessionId=${sessionId}`,
+                method: 'GET',
+                headers: {
+                    'Accept': 'application/json',
+                    'Content-Type': 'application/json'
+                }
+            };
+
+            console.log('🚀 DEBUG: Sending request to nekolabs API...');
+            const req = https.request(options, (res) => {
+                let data = '';
+
+                console.log(`📡 DEBUG: API response status: ${res.statusCode}`);
+
+                res.on('data', (chunk) => {
+                    data += chunk;
+                });
+
+                res.on('end', () => {
+                    try {
+                        console.log('📄 DEBUG: API response received');
+                        const response = JSON.parse(data);
+                        console.log('🔍 DEBUG: Full API response:', response);
+                        
+                        if (response.success && response.result) {
+                            console.log(`✅ DEBUG: Text extraction successful: "${response.result}"`);
+                            resolve({ status: true, response: response.result });
+                        } else {
+                            console.log('❌ DEBUG: API returned error:', response);
+                            resolve({ status: false, response: response.result || 'Gagal mengekstrak teks' });
+                        }
+                    } catch (error) {
+                        console.error('❌ DEBUG: Error parsing API response:', error);
+                        reject(error);
+                    }
+                });
+            });
+
+            req.on('error', (error) => {
+                console.error('❌ DEBUG: API request error:', error);
+                reject(error);
+            });
+
+            req.end();
+            console.log('📤 DEBUG: Request sent to API');
+
+        } catch (error) {
+            console.error('❌ DEBUG: extractTextFromImage error:', error);
+            reject(error);
+        }
+    });
+}
+
+module.exports = { 
+    extractTextFromImage,
+    getRandomSessionId,
+    uploadImageToHosting
+};

endpoints/turnstile.js

@@ -0,0 +1,84 @@
+async function turnstile({ domain, proxy, siteKey }, page) {
+  if (!domain) throw new Error("Missing domain parameter");
+  if (!siteKey) throw new Error("Missing siteKey parameter");
+
+  const timeout = global.timeOut || 60000;
+  let isResolved = false;
+
+  const cl = setTimeout(async () => {
+    if (!isResolved) {
+      throw new Error("Timeout Error");
+    }
+  }, timeout);
+
+  try {
+    if (proxy?.username && proxy?.password) {
+      await page.authenticate({
+        username: proxy.username,
+        password: proxy.password,
+      });
+    }
+
+    const htmlContent = `
+      <!DOCTYPE html>
+      <html lang="en">
+      <body>
+        <div class="turnstile"></div>
+        <script src="https://challenges.cloudflare.com/turnstile/v0/api.js?onload=onloadTurnstileCallback" defer></script>
+        <script>
+          window.onloadTurnstileCallback = function () {
+            turnstile.render('.turnstile', {
+              sitekey: '${siteKey}',
+              callback: function (token) {
+                var c = document.createElement('input');
+                c.type = 'hidden';
+                c.name = 'cf-response';
+                c.value = token;
+                document.body.appendChild(c);
+              },
+            });
+          };
+        </script>
+      </body>
+      </html>
+    `;
+
+    await page.setRequestInterception(true);
+    page.removeAllListeners("request");
+    page.on("request", async (request) => {
+      if ([domain, domain + "/"].includes(request.url()) && request.resourceType() === "document") {
+        await request.respond({
+          status: 200,
+          contentType: "text/html",
+          body: htmlContent,
+        });
+      } else {
+        await request.continue();
+      }
+    });
+
+    await page.goto(domain, { waitUntil: "domcontentloaded" });
+
+    await page.waitForSelector('[name="cf-response"]', { timeout });
+
+    const token = await page.evaluate(() => {
+      try {
+        return document.querySelector('[name="cf-response"]').value;
+      } catch {
+        return null;
+      }
+    });
+
+    isResolved = true;
+    clearTimeout(cl);
+
+    if (!token || token.length < 10) throw new Error("Failed to get token");
+    return token;
+
+  } catch (e) {
+    clearTimeout(cl);
+    throw e;
+  }
+}
+
+module.exports = turnstile;