Update plugins/sora2.js

plugins/sora2.js

@@ -1,14 +1,52 @@
 const axios = require('axios');
+const { HttpsProxyAgent } = require('https-proxy-agent');
 const dns = require('dns').promises;
 
-const PROXY_URL = 'https://proxy-sigma-roan.vercel.app/api/proxy';
-
 dns.setServers([
     '1.1.1.1',
     '8.8.8.8',
     '8.8.4.4'
 ]);
 
+async function fetchProxyList() {
+    try {
+        const response = await axios.get('https://cdn.jsdelivr.net/gh/proxifly/free-proxy-list@main/proxies/protocols/https/data.txt');
+        const proxies = response.data
+            .split('\n')
+            .map(line => line.trim())
+            .filter(line => line.startsWith('http'));
+        return proxies;
+    } catch (err) {
+        return [];
+    }
+}
+
+function getRandomProxy(proxyList) {
+    if (proxyList.length === 0) return null;
+    const randomIndex = Math.floor(Math.random() * proxyList.length);
+    return proxyList[randomIndex];
+}
+
+async function createAxiosWithProxy(proxyList, baseURL) {
+    const proxy = getRandomProxy(proxyList);
+    
+    const config = {
+        baseURL,
+        timeout: 30000,
+        validateStatus: function (status) {
+            return status >= 200 && status < 600;
+        }
+    };
+    
+    if (proxy) {
+        const httpsAgent = new HttpsProxyAgent(proxy);
+        config.httpsAgent = httpsAgent;
+        config.proxy = false;
+    }
+    
+    return axios.create(config);
+}
+
 function generateUniqueId() {
     return Array.from({ length: 32 }, () => 
         Math.floor(Math.random() * 16).toString(16)
@@ -33,9 +71,7 @@ function generateRandomIP() {
     return `${Math.floor(Math.random() * 255)}.${Math.floor(Math.random() * 255)}.${Math.floor(Math.random() * 255)}.${Math.floor(Math.random() * 255)}`;
 }
 
-async function proxyRequest(url, options = {}) {
-    const targetPath = url.startsWith('http') ? url : url;
-    
+async function proxyRequest(proxyList, url, options = {}) {
     const fakeIP = generateRandomIP();
     
     const headers = {
@@ -49,42 +85,30 @@ async function proxyRequest(url, options = {}) {
     
     await randomDelay(500, 1500);
     
-    const axiosConfig = {
-        method: options.method || 'GET',
-        headers: headers,
-        timeout: 30000,
-        params: {
-            url: targetPath
-        },
-        validateStatus: function (status) {
-            return status >= 200 && status < 600;
-        }
-    };
-    
-    if (options.data && (options.method === 'POST' || options.method === 'PUT')) {
-        axiosConfig.data = options.data;
-    }
-    
     let lastError = null;
     
     for (let attempt = 1; attempt <= 3; attempt++) {
         try {
-            axiosConfig.url = PROXY_URL;
-            console.log(`Attempt ${attempt}: ${PROXY_URL}?url=${targetPath}`);
+            const axiosInstance = await createAxiosWithProxy(proxyList, 'https://api.bylo.ai');
             
-            const response = await axios(axiosConfig);
+            const axiosConfig = {
+                method: options.method || 'GET',
+                url: url,
+                headers: headers,
+            };
+            
+            if (options.data && (options.method === 'POST' || options.method === 'PUT')) {
+                axiosConfig.data = options.data;
+            }
             
-            console.log(`Attempt ${attempt} got status ${response.status}`);
-            console.log(`Response data:`, JSON.stringify(response.data).substring(0, 200));
+            const response = await axiosInstance(axiosConfig);
             
             if (response.status === 403) {
-                console.log('Got 403, waiting longer before retry...');
                 await randomDelay(3000, 5000);
                 throw new Error('API Bylo returned 403 Forbidden - possible rate limit or IP block');
             }
             
             if (response.status === 429) {
-                console.log('Got 429 Too Many Requests, waiting...');
                 await randomDelay(5000, 10000);
                 if (attempt < 3) continue;
                 throw new Error('Rate limit exceeded');
@@ -108,16 +132,9 @@ async function proxyRequest(url, options = {}) {
             
         } catch (error) {
             lastError = error;
-            console.error(`Attempt ${attempt} failed:`, error.message);
-            
-            if (error.response) {
-                console.error(`Response status: ${error.response.status}`);
-                console.error(`Response data:`, error.response.data);
-            }
             
             if (attempt < 3) {
                 const waitTime = 3000 * attempt;
-                console.log(`Retrying in ${waitTime/1000} seconds...`);
                 await randomDelay(waitTime, waitTime + 2000);
             }
         }
@@ -127,7 +144,6 @@ async function proxyRequest(url, options = {}) {
 }
 
 async function createTempEmail() {
-    console.log('Creating temporary email...');
     const { data } = await axios.post('https://api.internal.temp-mail.io/api/v3/email/new', {
         min_name_length: 10,
         max_name_length: 10
@@ -141,14 +157,14 @@ async function createTempEmail() {
         timeout: 15000
     });
     
-    console.log(`Email created: ${data.email}`);
     return data;
 }
 
-async function getHcaptchaToken() {
-    console.log('Getting hCaptcha token...');
-    const { data } = await axios.get(
-        'https://anabot.my.id/api/tools/bypass?url=https%3A%2F%2Fapi.hcaptcha.com&siteKey=6f70c0f2-3ef6-4972-9fb6-c0b4bade3af8&type=hcaptcha-invisible&apikey=freeApikey',
+async function getHcaptchaToken(proxyList) {
+    const axiosInstance = await createAxiosWithProxy(proxyList, 'https://anabot.my.id');
+    
+    const { data } = await axiosInstance.get(
+        '/api/tools/bypass?url=https%3A%2F%2Fapi.hcaptcha.com&siteKey=6f70c0f2-3ef6-4972-9fb6-c0b4bade3af8&type=hcaptcha-invisible&apikey=freeApikey',
         {
             timeout: 15000
         }
@@ -158,21 +174,19 @@ async function getHcaptchaToken() {
         throw new Error('Failed to get hCaptcha token');
     }
     
-    console.log('hCaptcha token obtained');
     return data.data.result.token;
 }
 
-async function sendVerificationEmail(email) {
-    console.log(`Sending verification email to ${email}...`);
-    
+async function sendVerificationEmail(proxyList, email) {
     await randomDelay(1000, 2000);
     
-    const hcaptchaToken = await getHcaptchaToken();
+    const hcaptchaToken = await getHcaptchaToken(proxyList);
     const encodedEmail = encodeURIComponent(email);
     
     await randomDelay(500, 1000);
     
     const { data } = await proxyRequest(
+        proxyList,
         `/api/auth/send-captcha?email=${encodedEmail}&type=register`,
         {
             method: 'GET',
@@ -188,13 +202,11 @@ async function sendVerificationEmail(email) {
         throw new Error(`Failed to send verification email: ${data.msg || 'Unknown error'}`);
     }
     
-    console.log('Verification email sent successfully');
     await randomDelay(3000, 5000);
     return true;
 }
 
 async function getVerificationCode(email) {
-    console.log('Waiting for verification code...');
     let attempts = 0;
     const maxAttempts = 30;
     
@@ -220,15 +232,12 @@ async function getVerificationCode(email) {
                 const codeMatch = bodyText.match(/Verification Code:\s*(\d{6})/);
                 
                 if (codeMatch) {
-                    console.log(`Verification code received: ${codeMatch[1]}`);
                     return codeMatch[1];
                 }
             }
             
             attempts++;
-            console.log(`Checking for verification code... attempt ${attempts}/${maxAttempts}`);
         } catch (error) {
-            console.log(`Email check attempt ${attempts} failed:`, error.message);
             attempts++;
         }
     }
@@ -236,9 +245,8 @@ async function getVerificationCode(email) {
     throw new Error('Verification code not received after 30 attempts');
 }
 
-async function registerAccount(email, password, verificationCode) {
-    console.log('Registering account...');
-    const { data } = await proxyRequest('/api/auth/register', {
+async function registerAccount(proxyList, email, password, verificationCode) {
+    const { data } = await proxyRequest(proxyList, '/api/auth/register', {
         method: 'POST',
         headers: {
             'Accept': 'application/json, text/plain, */*',
@@ -258,15 +266,13 @@ async function registerAccount(email, password, verificationCode) {
         throw new Error(`Registration failed: ${data.msg || 'Unknown error'}`);
     }
     
-    console.log('Account registered successfully');
     return data.data.token;
 }
 
-async function createVideo(prompt, ratio, authToken, email) {
-    console.log('Creating video task...');
+async function createVideo(proxyList, prompt, ratio, authToken, email) {
     await randomDelay(2000, 3000);
     
-    const { data } = await proxyRequest('/aimodels/api/v1/ai/video/create', {
+    const { data } = await proxyRequest(proxyList, '/aimodels/api/v1/ai/video/create', {
         method: 'POST',
         headers: {
             'Content-Type': 'application/json',
@@ -294,13 +300,13 @@ async function createVideo(prompt, ratio, authToken, email) {
         throw new Error(`Failed to create video: ${data.message || 'Unknown error'}`);
     }
     
-    console.log(`Video task created with ID: ${data.data}`);
     return data.data;
 }
 
-async function getTaskStatus(taskId, authToken) {
+async function getTaskStatus(proxyList, taskId, authToken) {
     try {
         const { data } = await proxyRequest(
+            proxyList,
             `/aimodels/api/v1/ai/${taskId}?channel=SORA2`,
             {
                 method: 'GET',
@@ -317,26 +323,21 @@ async function getTaskStatus(taskId, authToken) {
         
         return data.data;
     } catch (error) {
-        console.error('Error getting task status:', error.message);
         throw error;
     }
 }
 
-async function waitForVideoCompletion(taskId, authToken) {
-    console.log('Waiting for video generation...');
+async function waitForVideoCompletion(proxyList, taskId, authToken) {
     let attempts = 0;
     const maxAttempts = 120;
     
     while (attempts < maxAttempts) {
         await randomDelay(5000, 7000);
         
-        const taskData = await getTaskStatus(taskId, authToken);
-        
-        console.log(`Video status check ${attempts + 1}/${maxAttempts} - State: ${taskData.state}`);
+        const taskData = await getTaskStatus(proxyList, taskId, authToken);
         
         if (taskData.state === 1 && taskData.completeData) {
             const completeData = JSON.parse(taskData.completeData);
-            console.log('Video generation completed!');
             return completeData.data.result_urls[0];
         }
         
@@ -351,22 +352,17 @@ async function waitForVideoCompletion(taskId, authToken) {
 }
 
 async function sora2(prompt, ratio = 'portrait') {
-    console.log('=== Starting Sora2 Video Generation ===');
-    console.log(`Prompt: ${prompt}`);
-    console.log(`Ratio: ${ratio}`);
+    const proxyList = await fetchProxyList();
     
     const tempMail = await createTempEmail();
     const email = tempMail.email;
     const password = generatePassword();
     
-    await sendVerificationEmail(email);
+    await sendVerificationEmail(proxyList, email);
     const verificationCode = await getVerificationCode(email);
-    const authToken = await registerAccount(email, password, verificationCode);
-    const taskId = await createVideo(prompt, ratio, authToken, email);
-    const videoUrl = await waitForVideoCompletion(taskId, authToken);
-    
-    console.log('=== Video Generation Completed ===');
-    console.log(`Video URL: ${videoUrl}`);
+    const authToken = await registerAccount(proxyList, email, password, verificationCode);
+    const taskId = await createVideo(proxyList, prompt, ratio, authToken, email);
+    const videoUrl = await waitForVideoCompletion(proxyList, taskId, authToken);
     
     return {
         success: true,
@@ -408,21 +404,10 @@ const handler = async (req, res) => {
             });
         }
         
-        console.log(`\n${'='.repeat(60)}`);
-        console.log('NEW REQUEST RECEIVED');
-        console.log(`Prompt: ${prompt}`);
-        console.log(`Ratio: ${ratio}`);
-        console.log(`${'='.repeat(60)}\n`);
-        
         const result = await sora2(prompt, ratio);
         
         const duration = ((Date.now() - startTime) / 1000).toFixed(2);
         
-        console.log(`\n${'='.repeat(60)}`);
-        console.log('REQUEST COMPLETED');
-        console.log(`Duration: ${duration}s`);
-        console.log(`${'='.repeat(60)}\n`);
-        
         res.json({
             author: 'Herza',
             success: true,
@@ -440,9 +425,6 @@ const handler = async (req, res) => {
             }
         });
     } catch (error) {
-        console.error('\n❌ ERROR:', error.message);
-        console.error('Stack:', error.stack);
-        
         const duration = ((Date.now() - startTime) / 1000).toFixed(2);
         
         res.status(500).json({
@@ -460,7 +442,7 @@ const handler = async (req, res) => {
 
 module.exports = {
     name: 'Sora2 Video Generator',
-    description: 'Generate videos using Sora2 AI model from Bylo.ai via Vercel Proxy',
+    description: 'Generate videos using Sora2 AI model from Bylo.ai with Random Proxy',
     type: 'GET',
     routes: ['api/AI/sora2'],
     tags: ['AI', 'Sora', 'OpenAI', 'Video'],