Update plugins/sora2.js

plugins/sora2.js

@@ -1,52 +1,14 @@
 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)
@@ -71,7 +33,9 @@ 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(proxyList, url, options = {}) {
+async function proxyRequest(url, options = {}) {
+    const targetPath = url.startsWith('http') ? url : url;
+    
     const fakeIP = generateRandomIP();
     
     const headers = {
@@ -85,30 +49,42 @@ async function proxyRequest(proxyList, 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 {
-            const axiosInstance = await createAxiosWithProxy(proxyList, 'https://api.bylo.ai');
+            axiosConfig.url = PROXY_URL;
+            console.log(`Attempt ${attempt}: ${PROXY_URL}?url=${targetPath}`);
             
-            const axiosConfig = {
-                method: options.method || 'GET',
-                url: url,
-                headers: headers,
-            };
-            
-            if (options.data && (options.method === 'POST' || options.method === 'PUT')) {
-                axiosConfig.data = options.data;
-            }
+            const response = await axios(axiosConfig);
             
-            const response = await axiosInstance(axiosConfig);
+            console.log(`Attempt ${attempt} got status ${response.status}`);
+            console.log(`Response data:`, JSON.stringify(response.data).substring(0, 200));
             
             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');
@@ -132,9 +108,16 @@ async function proxyRequest(proxyList, 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);
             }
         }
@@ -144,6 +127,7 @@ async function proxyRequest(proxyList, 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
@@ -157,14 +141,14 @@ async function createTempEmail() {
         timeout: 15000
     });
     
+    console.log(`Email created: ${data.email}`);
     return data;
 }
 
-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',
+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',
         {
             timeout: 15000
         }
@@ -174,19 +158,21 @@ async function getHcaptchaToken(proxyList) {
         throw new Error('Failed to get hCaptcha token');
     }
     
+    console.log('hCaptcha token obtained');
     return data.data.result.token;
 }
 
-async function sendVerificationEmail(proxyList, email) {
+async function sendVerificationEmail(email) {
+    console.log(`Sending verification email to ${email}...`);
+    
     await randomDelay(1000, 2000);
     
-    const hcaptchaToken = await getHcaptchaToken(proxyList);
+    const hcaptchaToken = await getHcaptchaToken();
     const encodedEmail = encodeURIComponent(email);
     
     await randomDelay(500, 1000);
     
     const { data } = await proxyRequest(
-        proxyList,
         `/api/auth/send-captcha?email=${encodedEmail}&type=register`,
         {
             method: 'GET',
@@ -202,11 +188,13 @@ async function sendVerificationEmail(proxyList, 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;
     
@@ -232,12 +220,15 @@ 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++;
         }
     }
@@ -245,8 +236,9 @@ async function getVerificationCode(email) {
     throw new Error('Verification code not received after 30 attempts');
 }
 
-async function registerAccount(proxyList, email, password, verificationCode) {
-    const { data } = await proxyRequest(proxyList, '/api/auth/register', {
+async function registerAccount(email, password, verificationCode) {
+    console.log('Registering account...');
+    const { data } = await proxyRequest('/api/auth/register', {
         method: 'POST',
         headers: {
             'Accept': 'application/json, text/plain, */*',
@@ -266,13 +258,15 @@ async function registerAccount(proxyList, email, password, verificationCode) {
         throw new Error(`Registration failed: ${data.msg || 'Unknown error'}`);
     }
     
+    console.log('Account registered successfully');
     return data.data.token;
 }
 
-async function createVideo(proxyList, prompt, ratio, authToken, email) {
+async function createVideo(prompt, ratio, authToken, email) {
+    console.log('Creating video task...');
     await randomDelay(2000, 3000);
     
-    const { data } = await proxyRequest(proxyList, '/aimodels/api/v1/ai/video/create', {
+    const { data } = await proxyRequest('/aimodels/api/v1/ai/video/create', {
         method: 'POST',
         headers: {
             'Content-Type': 'application/json',
@@ -300,13 +294,13 @@ async function createVideo(proxyList, 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(proxyList, taskId, authToken) {
+async function getTaskStatus(taskId, authToken) {
     try {
         const { data } = await proxyRequest(
-            proxyList,
             `/aimodels/api/v1/ai/${taskId}?channel=SORA2`,
             {
                 method: 'GET',
@@ -323,21 +317,26 @@ async function getTaskStatus(proxyList, taskId, authToken) {
         
         return data.data;
     } catch (error) {
+        console.error('Error getting task status:', error.message);
         throw error;
     }
 }
 
-async function waitForVideoCompletion(proxyList, taskId, authToken) {
+async function waitForVideoCompletion(taskId, authToken) {
+    console.log('Waiting for video generation...');
     let attempts = 0;
     const maxAttempts = 120;
     
     while (attempts < maxAttempts) {
         await randomDelay(5000, 7000);
         
-        const taskData = await getTaskStatus(proxyList, taskId, authToken);
+        const taskData = await getTaskStatus(taskId, authToken);
+        
+        console.log(`Video status check ${attempts + 1}/${maxAttempts} - State: ${taskData.state}`);
         
         if (taskData.state === 1 && taskData.completeData) {
             const completeData = JSON.parse(taskData.completeData);
+            console.log('Video generation completed!');
             return completeData.data.result_urls[0];
         }
         
@@ -352,17 +351,22 @@ async function waitForVideoCompletion(proxyList, taskId, authToken) {
 }
 
 async function sora2(prompt, ratio = 'portrait') {
-    const proxyList = await fetchProxyList();
+    console.log('=== Starting Sora2 Video Generation ===');
+    console.log(`Prompt: ${prompt}`);
+    console.log(`Ratio: ${ratio}`);
     
     const tempMail = await createTempEmail();
     const email = tempMail.email;
     const password = generatePassword();
     
-    await sendVerificationEmail(proxyList, email);
+    await sendVerificationEmail(email);
     const verificationCode = await getVerificationCode(email);
-    const authToken = await registerAccount(proxyList, email, password, verificationCode);
-    const taskId = await createVideo(proxyList, prompt, ratio, authToken, email);
-    const videoUrl = await waitForVideoCompletion(proxyList, taskId, authToken);
+    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}`);
     
     return {
         success: true,
@@ -404,10 +408,21 @@ 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,
@@ -425,6 +440,9 @@ 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({
@@ -442,7 +460,7 @@ const handler = async (req, res) => {
 
 module.exports = {
     name: 'Sora2 Video Generator',
-    description: 'Generate videos using Sora2 AI model from Bylo.ai with Random Proxy',
+    description: 'Generate videos using Sora2 AI model from Bylo.ai via Vercel Proxy',
     type: 'GET',
     routes: ['api/AI/sora2'],
     tags: ['AI', 'Sora', 'OpenAI', 'Video'],