Update plugins/sora2.js

plugins/sora2.js

@@ -39,24 +39,23 @@ async function proxyRequest(path, options = {}) {
     const proxyAgent = new HttpsProxyAgent(PROXY_URL);
     
     const headers = {
-        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
         'Accept': 'application/json, text/plain, */*',
         'Accept-Language': 'en-US,en;q=0.9',
         'X-Forwarded-For': fakeIP,
         'X-Real-IP': fakeIP,
-        'X-Client-IP': fakeIP,
         'Origin': 'https://bylo.ai',
         'Referer': 'https://bylo.ai/',
         ...(options.headers || {})
     };
     
-    await randomDelay(500, 1500);
+    await randomDelay(300, 800);
     
     const axiosConfig = {
         url: fullUrl,
         method: options.method || 'GET',
         headers: headers,
-        timeout: 25000,
+        timeout: 60000,
         httpAgent: proxyAgent,
         httpsAgent: proxyAgent,
         proxy: false,
@@ -73,60 +72,62 @@ async function proxyRequest(path, options = {}) {
     
     for (let attempt = 1; attempt <= 3; attempt++) {
         try {
-            console.log(`Attempt ${attempt}: ${fullUrl}`);
+            console.log(`[${new Date().toISOString()}] Attempt ${attempt}: ${fullUrl}`);
             
             const response = await axios(axiosConfig);
             
-            console.log(`Attempt ${attempt} got status ${response.status}`);
-            console.log(`Response data:`, JSON.stringify(response.data).substring(0, 200));
+            console.log(`[${new Date().toISOString()}] Status ${response.status}`);
             
             if (response.status === 403) {
-                console.log('Got 403, waiting longer before retry...');
+                console.log('Got 403, waiting...');
                 await randomDelay(3000, 5000);
-                throw new Error('API Bylo returned 403 Forbidden - possible rate limit or IP block');
+                throw new Error('403 Forbidden');
             }
             
             if (response.status === 429) {
-                console.log('Got 429 Too Many Requests, waiting...');
-                await randomDelay(5000, 10000);
+                console.log('Got 429, waiting...');
+                await randomDelay(5000, 8000);
                 if (attempt < 3) continue;
                 throw new Error('Rate limit exceeded');
             }
             
             if (response.status >= 200 && response.status < 300) {
                 if (!response.data) {
-                    throw new Error('Empty response from proxy');
+                    throw new Error('Empty response');
                 }
                 return response;
             }
             
             if (response.status >= 400) {
-                const errorMsg = response.data?.msg || response.data?.message || response.data?.error || 'Unknown error';
+                const errorMsg = response.data?.msg || response.data?.message || 'Unknown error';
                 throw new Error(`API error (${response.status}): ${errorMsg}`);
             }
             
             if (attempt < 3) {
-                await randomDelay(2000, 4000);
+                await randomDelay(2000, 3000);
             }
             
         } catch (error) {
             lastError = error;
-            console.error(`Attempt ${attempt} failed:`, error.message);
+            console.error(`[${new Date().toISOString()}] Attempt ${attempt} failed:`, error.message);
+            
+            if (error.code === 'ECONNABORTED' || error.message.includes('timeout')) {
+                console.error('Timeout error detected');
+            }
             
             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);
+                const waitTime = 2000 * attempt;
+                console.log(`Retrying in ${waitTime/1000}s...`);
+                await randomDelay(waitTime, waitTime + 1000);
             }
         }
     }
     
-    throw new Error(`Proxy request failed after 3 attempts: ${lastError?.message || 'Unknown error'}`);
+    throw new Error(`Proxy request failed: ${lastError?.message || 'Unknown error'}`);
 }
 
 async function createTempEmail() {
@@ -141,7 +142,7 @@ async function createTempEmail() {
             'Application-Version': '4.0.0',
             'X-CORS-Header': 'iaWg3pchvFx48fY'
         },
-        timeout: 15000
+        timeout: 20000
     });
     
     console.log(`Email created: ${data.email}`);
@@ -153,7 +154,7 @@ async function getHcaptchaToken() {
     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
+            timeout: 30000
         }
     );
     
@@ -168,12 +169,12 @@ async function getHcaptchaToken() {
 async function sendVerificationEmail(email) {
     console.log(`Sending verification email to ${email}...`);
     
-    await randomDelay(1000, 2000);
+    await randomDelay(500, 1000);
     
     const hcaptchaToken = await getHcaptchaToken();
     const encodedEmail = encodeURIComponent(email);
     
-    await randomDelay(500, 1000);
+    await randomDelay(300, 700);
     
     const { data } = await proxyRequest(
         `/api/auth/send-captcha?email=${encodedEmail}&type=register`,
@@ -192,18 +193,18 @@ async function sendVerificationEmail(email) {
     }
     
     console.log('Verification email sent successfully');
-    await randomDelay(3000, 5000);
+    await randomDelay(2000, 3000);
     return true;
 }
 
 async function getVerificationCode(email) {
     console.log('Waiting for verification code...');
     let attempts = 0;
-    const maxAttempts = 30;
+    const maxAttempts = 25;
     
     while (attempts < maxAttempts) {
         try {
-            await new Promise(resolve => setTimeout(resolve, 5000));
+            await new Promise(resolve => setTimeout(resolve, 4000));
             
             const { data } = await axios.get(
                 `https://api.internal.temp-mail.io/api/v3/email/${email}/messages`,
@@ -214,7 +215,7 @@ async function getVerificationCode(email) {
                         'Application-Version': '4.0.0',
                         'X-CORS-Header': 'iaWg3pchvFx48fY'
                     },
-                    timeout: 10000
+                    timeout: 15000
                 }
             );
             
@@ -229,14 +230,14 @@ async function getVerificationCode(email) {
             }
             
             attempts++;
-            console.log(`Checking for verification code... attempt ${attempts}/${maxAttempts}`);
+            console.log(`Checking code... ${attempts}/${maxAttempts}`);
         } catch (error) {
-            console.log(`Email check attempt ${attempts} failed:`, error.message);
+            console.log(`Email check failed:`, error.message);
             attempts++;
         }
     }
     
-    throw new Error('Verification code not received after 30 attempts');
+    throw new Error('Verification code not received');
 }
 
 async function registerAccount(email, password, verificationCode) {
@@ -262,8 +263,6 @@ async function registerAccount(email, password, verificationCode) {
     }
     
     console.log('Account registered successfully');
-    console.log(`Email: ${email}`);
-    console.log(`Password: ${password}`);
     
     return {
         token: data.data.token,
@@ -274,7 +273,7 @@ async function registerAccount(email, password, verificationCode) {
 
 async function createVideoTask(prompt, ratio, authToken, email) {
     console.log('Creating video task...');
-    await randomDelay(2000, 3000);
+    await randomDelay(1000, 2000);
     
     const { data } = await proxyRequest('/aimodels/api/v1/ai/video/create', {
         method: 'POST',
@@ -335,14 +334,14 @@ async function getTaskStatus(taskId, authToken) {
 async function waitForVideoCompletion(taskId, authToken) {
     console.log('Waiting for video generation...');
     let attempts = 0;
-    const maxAttempts = 120;
+    const maxAttempts = 100;
     
     while (attempts < maxAttempts) {
-        await randomDelay(5000, 7000);
+        await randomDelay(4000, 6000);
         
         const taskData = await getTaskStatus(taskId, authToken);
         
-        console.log(`Video status check ${attempts + 1}/${maxAttempts} - State: ${taskData.state}`);
+        console.log(`Status check ${attempts + 1}/${maxAttempts} - State: ${taskData.state}`);
         
         if (taskData.state === 1 && taskData.completeData) {
             const completeData = JSON.parse(taskData.completeData);
@@ -357,7 +356,7 @@ async function waitForVideoCompletion(taskId, authToken) {
         attempts++;
     }
     
-    throw new Error('Video generation timeout after 10 minutes');
+    throw new Error('Video generation timeout');
 }
 
 async function sora2(prompt, ratio = 'portrait') {