Update index.js

index.js

@@ -18,8 +18,7 @@ const CONFIG = {
     BASE_URL: process.env.DENO_URL || "https://partyrock.aws/stream/getCompletion",//如果需要多号循环，需要设置你自己的denourl
     API_KEY: process.env.API_KEY || "sk-123456",//自定义你自己的认证密钥，记得修改
     RedisUrl: process.env.RedisUrl,
-    RedisToken: process.env.RedisToken,
-    CAPSOLVER_KEY: process.env.CAPSOLVER_KEY // 完全从环境变量读取
+    RedisToken: process.env.RedisToken
   },
   SERVER: {
     PORT: process.env.PORT || 3000,
@@ -101,34 +100,21 @@ 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) {
-      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();
-      }
-      
+      var wafToken = await Utils.extractWaf();
       if (wafToken) {
-        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持久化
+        Tokens[currentIndex].aws_waf_token = wafToken;
         await this.updateCacheTokens();
-        await this.updateRedisTokens();
+        this.updateRedisTokens();
+        currentIndex = (currentIndex + 1) % Tokens.length;
+        console.log("成功提取 aws-waf-token");
       } 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');
@@ -140,12 +126,11 @@ class TokenManager {
         if (idTokenMatch && idTokenMatch[1]) {
           Tokens[currentIndex].idToken = idTokenMatch[1];
         }
-        await this.updateRedisTokens();
+        this.updateRedisTokens();//最后更新redis数据库缓存,异步
         console.log("更新缓存完毕");
       }
+      currentIndex = (currentIndex + 1) % Tokens.length;
     }
-    // 单账号场景下轮换仍然无副作用
-    currentIndex = (currentIndex + 1) % Tokens.length;
   }
 }
 
@@ -164,44 +149,8 @@ class Utils {
       return type[Math.floor(Math.random() * type.length)]
     }
   }
-  static async solveAwsWaf(images, questionType = 'aws:grid') {
-    try {
-      console.log(`开始Capsolver验证 (类型: ${questionType}), 图片数量: ${images.length}`);
-      
-      const response = await fetch('https://api.capsolver.com/createTask', {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-          clientKey: CONFIG.API.CAPSOLVER_KEY,
-          task: {
-            type: 'AwsWafClassification',
-            websiteURL: Tokens[currentIndex].refreshUrl,
-            images: images,
-            question: questionType
-          }
-        })
-      });
-
-      const data = await response.json();
-      if (data.errorId === 0) {
-        if (data.status === 'ready') {
-          console.log(`✅ Capsolver验证成功 | 任务ID: ${data.taskId} | 使用图片: ${images.length}张`);
-          return data.solution;
-        }
-        console.log(`⏳ Capsolver处理中 | 任务ID: ${data.taskId} | 状态: ${data.status}`);
-      } else {
-        console.error(`❌ Capsolver错误 | 代码: ${data.errorCode} | 描述: ${data.errorDescription}`);
-      }
-      return null;
-    } catch (error) {
-      console.error('Capsolver请求失败:', error);
-      return null;
-    }
-  }
   static async extractWaf() {
-    puppeteer.use(StealthPlugin());
+    puppeteer.use(StealthPlugin())
     const browser = await puppeteer.launch({
       headless: true,
       args: [
@@ -212,62 +161,40 @@ class Utils {
       ],
       executablePath: CONFIG.CHROME_PATH
     });
-
     try {
       const page = await browser.newPage();
       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"]);
-
-      // 监听验证挑战事件，自动截屏并解决挑战
-      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}`);
-          }
-
-          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();
-              });
-            }, solution.objects);
-          }
-        }
-      });
-
-      // 进入验证页
+      await page.setUserAgent(
+        CONFIG.DEFAULT_HEADERS["User-Agent"]
+      )
       await page.goto(Tokens[currentIndex].refreshUrl, {
         waitUntil: 'networkidle2',
         timeout: 30000
       });
-
-      // 延长等待时间让挑战完成（根据实际情况可调整）
-      await page.waitForTimeout(5000);
-
-      // 再次等待，确保所有动态变动已结束
-      const cookies = await page.cookies();
-      const awsWafCookie = cookies.find(
+      await page.evaluate(() => {
+        // 随机滚动
+        window.scrollBy(0, Math.random() * 500)
+      })
+      await page.evaluate(() => {
+        return new Promise(resolve => setTimeout(resolve, 2000))
+      })
+      // 直接从页面 cookies 中提取 aws-waf-token
+      const awsWafToken = (await page.cookies()).find(
         cookie => cookie.name.toLowerCase() === 'aws-waf-token'
-      );
-      const awsWafToken = awsWafCookie ? awsWafCookie.value : null;
+      )?.value;
 
       if (awsWafToken) {
-        console.log(`🔑 成功获取aws-waf-token | 长度: ${awsWafToken.length}字符`);
+        await browser.close();
+        return awsWafToken;
       } else {
-        console.error('❌ 获取aws-waf-token失败');
+        await browser.close();
+        return null;
       }
 
-      await browser.close();
-      return awsWafToken;
     } catch (error) {
-      console.error('获取aws-waf-token出错:', error);
+      console.error('获取 aws-waf-token 出错:', error);
       await browser.close();
       return null;
     }
@@ -595,45 +522,55 @@ 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);
-
-    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}`, {
+    
+    try {
+      console.log("开始请求");
+      //发送请求
+      var response = await fetch(`${CONFIG.API.BASE_URL}`, {
         method: "POST",
-        headers: { ...CONFIG.DEFAULT_HEADERS },
+        headers: {
+          ...CONFIG.DEFAULT_HEADERS
+        },
         body: JSON.stringify(requestPayload)
       });
       reqStatus = 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);
+      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}`);
       }
-      return;
-    } else {
-      throw new Error(`请求失败! status: ${response.statusText}`);
+    } catch (error) {
+      throw new Error(`请求失败! status: ${response.status}`);
     }
   } catch (error) {
     res.status(parseInt(reqStatus)).json({