Update index.js

index.js

@@ -101,24 +101,34 @@ class TokenManager {
     CONFIG.DEFAULT_HEADERS.Cookie = `idToken=${Tokens[currentIndex].idToken}; pr_refresh_token=${Tokens[currentIndex].pr_refresh_token};aws-waf-token=${Tokens[currentIndex].aws_waf_token};cwr_s=${Tokens[currentIndex].cwr_s};cwr_u=${sessionId}`;
     CONFIG.DEFAULT_HEADERS.referer = Tokens[currentIndex].refreshUrl;
     CONFIG.DEFAULT_HEADERS["request-id"] = `request-id-${Utils.uuidv4()}`;
+    CONFIG.DEFAULT_HEADERS["User-Agent"] = await Utils.getRandomUserAgent();
   }
 
   async updateTokens(response, isWaf = false) {
     if (isWaf) {
-      var wafToken = await Utils.extractWaf();
+      let wafToken = await Utils.extractWaf();
+      console.log("原aws-waf-token:", Tokens[currentIndex].aws_waf_token);
+      
+      // 如果新 token 与旧 token 相同，等待后重试一次
+      if (wafToken === Tokens[currentIndex].aws_waf_token) {
+        console.log("⚠️ 更新后的aws-waf-token与现有token一致，等待后重试一次");
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        wafToken = await Utils.extractWaf();
+      }
+      
       if (wafToken) {
-        // 更新当前token的aws_waf_token
-        Tokens[currentIndex].aws_waf_token = wafToken;
-        // 立即更新缓存headers
+        console.log("新获取的aws-waf-token:", wafToken);
+        if (wafToken !== Tokens[currentIndex].aws_waf_token) {
+          console.log("✅ 成功更新aws-waf-token | 新token长度:", wafToken.length);
+          Tokens[currentIndex].aws_waf_token = wafToken;
+        } else {
+          console.log("⚠️ 重试后aws-waf-token依旧与现有token一致");
+        }
+        // 更新内存缓存和Redis持久化
         await this.updateCacheTokens();
-        // 更新Redis存储
         await this.updateRedisTokens();
-        console.log("✅ 成功更新aws-waf-token到缓存");
-        currentIndex = (currentIndex + 1) % Tokens.length;
       } else {
-        console.log("❌ 提取aws-waf-token失败，切换账号");
-        currentIndex = (currentIndex + 1) % Tokens.length;
-        await this.updateCacheTokens();
+        console.log("❌ 提取aws-waf-token失败");
       }
     } else {
       const newCsrfToken = response.headers.get('anti-csrftoken-a2z');
@@ -130,11 +140,12 @@ class TokenManager {
         if (idTokenMatch && idTokenMatch[1]) {
           Tokens[currentIndex].idToken = idTokenMatch[1];
         }
-        this.updateRedisTokens();//最后更新redis数据库缓存,异步
+        await this.updateRedisTokens();
         console.log("更新缓存完毕");
       }
-      currentIndex = (currentIndex + 1) % Tokens.length;
     }
+    // 单账号场景下轮换仍然无副作用
+    currentIndex = (currentIndex + 1) % Tokens.length;
   }
 }
 
@@ -190,10 +201,15 @@ class Utils {
     }
   }
   static async extractWaf() {
-    puppeteer.use(StealthPlugin())
+    puppeteer.use(StealthPlugin());
     const browser = await puppeteer.launch({
       headless: true,
-      args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage', '--disable-gpu'],
+      args: [
+        '--no-sandbox',
+        '--disable-setuid-sandbox',
+        '--disable-dev-shm-usage',
+        '--disable-gpu'
+      ],
       executablePath: CONFIG.CHROME_PATH
     });
 
@@ -202,28 +218,21 @@ class Utils {
       await page.setExtraHTTPHeaders({
         cookie: `pr_refresh_token=${Tokens[currentIndex].pr_refresh_token};idToken=${Tokens[currentIndex].idToken};aws-waf-token=${Tokens[currentIndex].aws_waf_token};cwr_s=${Tokens[currentIndex].cwr_s};cwr_u=${Utils.uuidv4()}`
       });
-      await page.setUserAgent(
-        CONFIG.DEFAULT_HEADERS["User-Agent"]
-      )
+      await page.setUserAgent(CONFIG.DEFAULT_HEADERS["User-Agent"]);
 
-      // 监听验证挑战
+      // 监听验证挑战事件，自动截屏并解决挑战
       page.on('response', async (response) => {
         if (response.url().includes('aws-waf-challenge')) {
           const screenshots = [];
-          
-          // 截取验证图片
           const challengeElements = await page.$$('.aws-waf-challenge');
           for (const element of challengeElements) {
             const screenshot = await element.screenshot({ encoding: 'base64' });
             screenshots.push(`data:image/png;base64,${screenshot}`);
           }
 
-          // 调用Capsolver
           const solution = await this.solveAwsWaf(screenshots, 'aws:grid');
-          
           if (solution?.objects) {
             console.log(`🎯 验证答案位置: ${solution.objects.join(', ')}`);
-            // 自动点击验证答案
             await page.evaluate((objects) => {
               document.querySelectorAll('.grid-item').forEach((el, index) => {
                 if (objects.includes(index)) el.click();
@@ -233,19 +242,21 @@ class Utils {
         }
       });
 
+      // 进入验证页
       await page.goto(Tokens[currentIndex].refreshUrl, {
         waitUntil: 'networkidle2',
         timeout: 30000
       });
 
-      // 新增：等待验证完成
-      await page.waitForTimeout(1000); // 等待1秒确保验证完成
-      await page.waitForSelector('.aws-waf-challenge', { hidden: true, timeout: 15000 });
+      // 延长等待时间让挑战完成（根据实际情况可调整）
+      await page.waitForTimeout(5000);
 
-      // 获取最终token
-      const awsWafToken = (await page.cookies()).find(
+      // 再次等待，确保所有动态变动已结束
+      const cookies = await page.cookies();
+      const awsWafCookie = cookies.find(
         cookie => cookie.name.toLowerCase() === 'aws-waf-token'
-      )?.value;
+      );
+      const awsWafToken = awsWafCookie ? awsWafCookie.value : null;
 
       if (awsWafToken) {
         console.log(`🔑 成功获取aws-waf-token | 长度: ${awsWafToken.length}字符`);
@@ -255,7 +266,6 @@ class Utils {
 
       await browser.close();
       return awsWafToken;
-
     } catch (error) {
       console.error('获取aws-waf-token出错:', error);
       await browser.close();
@@ -308,10 +318,8 @@ async function initializeService() {
   let index = 0;
   while (true) {
     console.log(index, '开始检测是否有缓存');
-    // 使用 JSON.parse 确保正确解析
     var checkRedis = await redisClient.get(`tokens_${index}`);
     if (checkRedis) {
-      // 尝试解析 JSON 字符串
       try {
         const parsedRedis = typeof checkRedis === 'string'
           ? JSON.parse(checkRedis)
@@ -333,6 +341,7 @@ async function initializeService() {
       const refreshUrl = process.env[`AUTH_TOKENS_${index}_REFRESH_URL`];
       const anti_csrftoken_a2z = process.env[`AUTH_TOKENS_${index}_ANTI_CSRF_TOKEN`];
       const cookie = process.env[`AUTH_TOKENS_${index}_COOKIE`];
+      const wafToken = process.env[`AUTH_TOKENS_${index}_WAF_TOKEN`];
 
       if (!refreshUrl && !anti_csrftoken_a2z && !cookie) {
         break;
@@ -344,7 +353,7 @@ async function initializeService() {
           refreshUrl,
           anti_csrftoken_a2z,
           pr_refresh_token: cookies["pr_refresh_token"],
-          aws_waf_token: cookies["aws-waf-token"],
+          aws_waf_token: wafToken || cookies["aws-waf-token"], // 优先使用独立的WAF token
           idToken: cookies["idToken"],
           cwr_s: cookies["cwr_s"]
         });
@@ -585,55 +594,45 @@ app.post('/hf/v1/chat/completions', async (req, res) => {
     if (authToken !== CONFIG.API.API_KEY) {
       return res.status(401).json({ error: "Unauthorized" });
     }
+    // 每次请求前确保请求头更新为最新的token信息
     await tokenManager.updateCacheTokens();
     const apiClient = new ApiClient(req.body.model);
     const requestPayload = await apiClient.transformMessages(req.body);
-    
-    try {
-      console.log("开始请求");
-      //发送请求
-      var response = await fetch(`${CONFIG.API.BASE_URL}`, {
+
+    console.log("开始请求");
+    let response = await fetch(`${CONFIG.API.BASE_URL}`, {
+      method: "POST",
+      headers: { ...CONFIG.DEFAULT_HEADERS },
+      body: JSON.stringify(requestPayload)
+    });
+    reqStatus = response.status;
+
+    // 当出现请求受限或人机验证时，先更新token，再重试一次
+    if ([202, 405].includes(reqStatus)) {
+      console.log("请求受限或人机验证，正在更新token并重试请求");
+      await tokenManager.updateTokens(response, true);
+      // 延时1秒，等待新token生效
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      response = await fetch(`${CONFIG.API.BASE_URL}`, {
         method: "POST",
-        headers: {
-          ...CONFIG.DEFAULT_HEADERS
-        },
+        headers: { ...CONFIG.DEFAULT_HEADERS },
         body: JSON.stringify(requestPayload)
       });
       reqStatus = response.status;
-      switch (reqStatus) {
-        case 200:
-          console.log("请求成功");
-          // 异步更新token
-          tokenManager.updateTokens(response)
-          // 处理响应
-          if (req.body.stream) {
-            await ResponseHandler.handleStreamResponse(response, req.body.model, res);
-          } else {
-            await ResponseHandler.handleNormalResponse(response, req.body.model, res);
-          }
-          return;
-        case 202:
-          console.log("请求受限，更新WAF");
-          await tokenManager.updateTokens(response, true);
-          throw new Error(`请求失败! status: ${response.statusText}，已刷新验证信息，请重新请求`);
-        case 405:
-          console.log("人机验证");
-          await tokenManager.updateTokens(response, true);//尝试获取waf，然后返回错误提示。
-          throw new Error(`请求失败! status: ${response.statusText}，人机验证，请重新请求，如果多次失败，请重新更换token`);
-        case 400:
-          console.log("信息过期，请求失败");
-          await tokenManager.updateTokens(response);
-          throw new Error(`请求失败! status: ${response.statusText}，已刷新验证信息，请重新请求`);
-        case 403:
-          console.log("请求被阻止");
-          await tokenManager.updateTokens(response, true);//尝试获取waf，然后返回错误提示。
-          CONFIG.DEFAULT_HEADERS["User-Agent"] = await Utils.getRandomUserAgent();
-          throw new Error(`请求失败! status: ${response.statusText}，请重新请求，如果多次失败，请重新更换token`);
-        default:
-          throw new Error(`请求失败! status: ${response.status}`);
+    }
+
+    if (reqStatus === 200) {
+      console.log("请求成功");
+      // 异步更新token（注意此处可不用 await 以保证响应速度）
+      tokenManager.updateTokens(response);
+      if (req.body.stream) {
+        await ResponseHandler.handleStreamResponse(response, req.body.model, res);
+      } else {
+        await ResponseHandler.handleNormalResponse(response, req.body.model, res);
       }
-    } catch (error) {
-      throw new Error(`请求失败! status: ${response.status}`);
+      return;
+    } else {
+      throw new Error(`请求失败! status: ${response.statusText}`);
     }
   } catch (error) {
     res.status(parseInt(reqStatus)).json({