tt-help-cli-ycl 1.4.136 → 1.4.140

package/src/cli/tag.js

@@ -1,10 +1,15 @@
-import { writeFileSync, unlinkSync } from "fs";
+import { writeFileSync } from "fs";
 import { randomUUID } from "crypto";
-import { execSync } from "child_process";
 import http from "http";
-import os from "os";
-import path from "path";
 import readline from "readline";
+import {
+  getBrowserMemory,
+  formatMemoryWithBrowser,
+} from "../lib/browser-memory.js";
+import {
+  reportConsecutiveTaskErrors,
+  reportClientErrorAndFailover,
+} from "../lib/client-error-report.js";
 import { fetchTagData, enrichVideosWithLocation } from "../lib/tag-fetcher.js";
 import { killEdgeProcesses, ensureBrowserReady } from "../lib/browser/cdp.js";
 import { getOrCreatePage, isBrowserClosedError } from "../lib/browser/page.js";
@@ -99,92 +104,6 @@ async function waitForPortReleased(port, timeoutMs = 10000) {
   return !(await checkPortListening(port));
 }
 
-function formatMemoryUsage(mem = process.memoryUsage()) {
-  return `rss:${(mem.rss / 1024 / 1024).toFixed(0)}MB heap:${(mem.heapUsed / 1024 / 1024).toFixed(0)}MB ext:${(mem.external / 1024 / 1024).toFixed(0)}MB ab:${(mem.arrayBuffers / 1024 / 1024).toFixed(0)}MB`;
-}
-
-/**
- * 获取 Edge 浏览器进程的内存占用（macOS/Linux）
- */
-function getBrowserMemory(port = null) {
-  try {
-    const platform = os.platform();
-    let cmd;
-    if (platform === "darwin") {
-      // 按端口筛选：匹配 --remote-debugging-port=PORT 的进程
-      if (port) {
-        cmd = `ps aux | grep "[M]icrosoft Edge" | grep "remote-debugging-port=${port}" | awk '{sum += $6} END {printf "%d", sum/1024}'`;
-      } else {
-        cmd =
-          'ps aux | grep "[M]icrosoft Edge" | awk \'{sum += $6} END {printf "%d", sum/1024}\'';
-      }
-    } else if (platform === "linux") {
-      if (port) {
-        cmd = `ps aux | grep "[m]sedge" | grep "remote-debugging-port=${port}" | awk '{sum += $6} END {printf "%d", sum/1024}'`;
-      } else {
-        cmd =
-          'ps aux | grep "[m]sedge" | awk \'{sum += $6} END {printf "%d", sum/1024}\'';
-      }
-    } else if (platform === "win32") {
-      // Windows: 用 PowerShell 查 msedge 进程内存（WorkingSet64 → MB）
-      // 用临时 .ps1 文件避免命令行转义问题
-      const ps1Path = path.join(os.tmpdir(), `edge-mem-${Date.now()}.ps1`);
-      try {
-        let ps1Content;
-        if (port) {
-          ps1Content =
-            `$procs = Get-CimInstance Win32_Process -Filter "Name LIKE 'msedge%'" -ErrorAction SilentlyContinue; ` +
-            `$sum = 0; ` +
-            `foreach ($p in $procs) { ` +
-            `  if ($p.CommandLine -and $p.CommandLine -like "*--remote-debugging-port=${port}*") { ` +
-            `    $sum += $p.WorkingSetSize ` +
-            `  } ` +
-            `}; ` +
-            `Write-Output $sum`;
-        } else {
-          // 无端口场景：Get-Process（.NET API，不依赖 WMI）统计全部 msedge 工作集，
-          // 与原 Get-CimInstance 全量求和行为等价；WMI 损坏/禁用的机器也能返回
-          ps1Content =
-            `$procs = Get-Process msedge -ErrorAction SilentlyContinue; ` +
-            `$sum = 0; ` +
-            `foreach ($p in $procs) { $sum += $p.WorkingSet64 }; ` +
-            `Write-Output $sum`;
-        }
-        writeFileSync(ps1Path, ps1Content);
-        cmd = `powershell.exe -NoProfile -ExecutionPolicy Bypass -File "${ps1Path}"`;
-        const result = execSync(cmd, { timeout: 5000 }).toString().trim();
-        try {
-          unlinkSync(ps1Path);
-        } catch {}
-        // PowerShell 返回 WorkingSetSize（字节），需除以 1048576 得 MB
-        const bytes = parseInt(result, 10);
-        const mb = bytes > 0 ? Math.round(bytes / 1048576) : 0;
-        return mb > 0 ? mb : null;
-      } catch {
-        try {
-          unlinkSync(ps1Path);
-        } catch {}
-        return null;
-      }
-    } else {
-      return null;
-    }
-    // macOS/Linux: ps RSS 是 KB，awk 已除以 1024 得 MB
-    const result = execSync(cmd, { timeout: 5000 }).toString().trim();
-    const mb = parseInt(result, 10);
-    return mb > 0 ? mb : null;
-  } catch {
-    return null;
-  }
-}
-
-function formatMemoryWithBrowser(port = null) {
-  const nodeMem = formatMemoryUsage();
-  const browserMB = getBrowserMemory(port);
-  const portLabel = port ? `:${port}` : "";
-  return browserMB ? `${nodeMem} edge${portLabel}:${browserMB}MB` : nodeMem;
-}
-
 // 构建带客户端追踪 header 的 fetch 封装
 function buildClientHeaders(clientId, meta, extra = {}) {
   return {
@@ -266,9 +185,10 @@ async function enrichWithServerCache(
     }
   }
 
-  // Step 3: 给已知国家的视频赋值，收集未知视频
+  // Step 3: 给已知国家的视频赋值，收集未知视频（已有国家的跳过，避免重复 enrich）
   const unknownVideos = [];
   for (const v of videos) {
+    if (v.locationCreated) continue; // 已识别到国家，不再重复补
     const loc = knownLocations[v.authorUniqueId];
     if (loc) {
       v.locationCreated = loc;
@@ -1011,7 +931,7 @@ export async function handleScoreAll(parsed) {
       parseInt(process.env.TAG_SCOREALL_PERIODIC_RECYCLE_EVERY || "0", 10) || 0,
     ),
     switchPortOnRecycle:
-      String(process.env.TAG_SCOREALL_SWITCH_PORT_ON_RECYCLE || "1") !== "0",
+      String(process.env.TAG_SCOREALL_SWITCH_PORT_ON_RECYCLE || "0") !== "0",
   };
   let lastRecycleAt = 0;
 
@@ -1124,8 +1044,26 @@ export async function handleScoreAll(parsed) {
   let emptyRounds = 0; // 连续无任务的轮数
   let consecutiveCaptcha = 0;
   const MAX_CONSECUTIVE_CAPTCHA = 3;
-  let consecutive403 = 0; // 连续 HTTP 403 次数，达 3 次认为被封
-  const CONSECUTIVE_403_BLOCKED = 3; // 连续 3 次 403 认为账号被封
+  let consecutiveTaskErrors = 0; // 连续任务处理错误计数（达阈值后上报服务端）
+  const CONSECUTIVE_TASK_ERRORS_MAX = Math.max(
+    1,
+    parseInt(
+      process.env.TAG_SCOREALL_CONSECUTIVE_TASK_ERRORS_MAX || "20",
+      10,
+    ) || 20,
+  ); // 连续任务错误阈值，达到后上报 /api/error-report
+
+  // ── 403 判封 + 重试机制 ──
+  let currentTag = null; // 当前正在处理的 tag（403 重试时复用，不消耗下一个）
+  let retrySameTag = false; // 是否重试同一个 tag
+  let tag403Attempts = 0; // 当前 tag 已发生 403 的次数
+  let bannedCount = 0; // 连续判定“被封”的次数（成功 tag 清零）
+  // 按判封次数递增的重试预算：第 1 次判封前重试 30、第 2 次 40、第 3 次及以后 50
+  const BAN_RETRY_BUDGETS = [
+    parseInt(process.env.TAG_SCOREALL_403_RETRY_1 || "30", 10) || 30,
+    parseInt(process.env.TAG_SCOREALL_403_RETRY_2 || "40", 10) || 40,
+    parseInt(process.env.TAG_SCOREALL_403_RETRY_3 || "50", 10) || 50,
+  ];
 
   // 生成客户端 ID，用于服务端追踪
   const clientId = randomUUID();
@@ -1194,39 +1132,43 @@ export async function handleScoreAll(parsed) {
         return;
       }
       try {
-        // 从服务端取下一个 new 标签（同时查剩余数量）
-        const tagsRes = await fetch(
-          `${baseUrl}/api/tags?status=new&limit=1&userId=${encodeURIComponent(userId)}`,
-          {
-            headers: buildClientHeaders(clientId, clientMeta),
-          },
-        );
-        const tagsData = await tagsRes.json();
-
-        if (!tagsData.tags || tagsData.tags.length === 0) {
-          emptyRounds++;
-
-          // 服务端定时发现会自动补充标签，客户端只需等待
-          if (emptyRounds >= 5) {
-            log(
-              `⏳ 连续 ${emptyRounds} 轮无标签，等待服务端发现补充（30 秒后重试）...`,
-            );
-            await new Promise((r) => setTimeout(r, 30000));
-            emptyRounds = 0;
+        let tag;
+        if (retrySameTag) {
+          // 403 重试：复用当前 tag，不消耗队列里的下一个
+          tag = currentTag;
+        } else {
+          // 从服务端取下一个 new 标签（同时查剩余数量）
+          const tagsRes = await fetch(
+            `${baseUrl}/api/tags?status=new&limit=1&userId=${encodeURIComponent(userId)}`,
+            {
+              headers: buildClientHeaders(clientId, clientMeta),
+            },
+          );
+          const tagsData = await tagsRes.json();
+
+          if (!tagsData.tags || tagsData.tags.length === 0) {
+            emptyRounds++;
+
+            // 服务端定时发现会自动补充标签，客户端只需等待
+            if (emptyRounds >= 5) {
+              log(
+                `⏳ 连续 ${emptyRounds} 轮无标签，等待服务端发现补充（30 秒后重试）...`,
+              );
+              await new Promise((r) => setTimeout(r, 30000));
+              emptyRounds = 0;
+              continue;
+            }
+            log(`⏳ 暂无待打分标签（连续 ${emptyRounds} 轮），10 秒后重试...`);
+            await new Promise((r) => setTimeout(r, 10000));
             continue;
           }
-          log(`⏳ 暂无待打分标签（连续 ${emptyRounds} 轮），10 秒后重试...`);
-          await new Promise((r) => setTimeout(r, 10000));
-          continue;
-        }
-
-        // 有任务了，重置计数器
-        emptyRounds = 0;
 
-        const tag = tagsData.tags[0].tag
-          .replace(/^#+/, "")
-          .trim()
-          .toLowerCase();
+          // 有任务了，重置计数器
+          emptyRounds = 0;
+          tag = tagsData.tags[0].tag.replace(/^#+/, "").trim().toLowerCase();
+          currentTag = tag;
+          tag403Attempts = 0;
+        }
         const startTime = Date.now();
 
         log(`[${totalScored + 1}] 正在打分 #${tag} ...`);
@@ -1244,31 +1186,37 @@ export async function handleScoreAll(parsed) {
         };
 
         // 锁定 tag（meta 中不放入 tag，避免非 ASCII 字符导致 header ByteString 报错）
-        const claimRes = await fetch(
-          `${baseUrl}/api/tags/claim?userId=${encodeURIComponent(userId)}`,
-          {
-            method: "POST",
-            headers: buildClientHeaders(clientId, clientMeta, {
-              "Content-Type": "application/json",
-            }),
-            body: JSON.stringify({ tag }),
-          },
-        );
-        const claimData = await claimRes.json();
-        if (!claimData.ok) {
-          // already claimed: 其他机器抢先了，跳过不标 dead
-          if (claimData.error && claimData.error.includes("already claimed")) {
-            log(`  ⏭️ 已被其他客户端锁定，跳过`);
+        // 403 重试时 tag 已被本客户端锁定，跳过 claim，直接复用
+        if (!retrySameTag) {
+          const claimRes = await fetch(
+            `${baseUrl}/api/tags/claim?userId=${encodeURIComponent(userId)}`,
+            {
+              method: "POST",
+              headers: buildClientHeaders(clientId, clientMeta, {
+                "Content-Type": "application/json",
+              }),
+              body: JSON.stringify({ tag }),
+            },
+          );
+          const claimData = await claimRes.json();
+          if (!claimData.ok) {
+            // already claimed: 其他机器抢先了，跳过不标 dead
+            if (
+              claimData.error &&
+              claimData.error.includes("already claimed")
+            ) {
+              log(`  ⏭️ 已被其他客户端锁定，跳过`);
+              await recyclePage();
+              continue;
+            }
+            log(`  ⚠️ 无法锁定 (${claimData.error})，标记为 dead 并跳过`);
+            result.error = claimData.error;
+            result.status = "dead";
+            await reportToServer(baseUrl, result, clientId, clientMeta, userId);
+            totalScored++;
             await recyclePage();
             continue;
           }
-          log(`  ⚠️ 无法锁定 (${claimData.error})，标记为 dead 并跳过`);
-          result.error = claimData.error;
-          result.status = "dead";
-          await reportToServer(baseUrl, result, clientId, clientMeta, userId);
-          totalScored++;
-          await recyclePage();
-          continue;
         }
 
         // 抓取视频（CDP 连接已登录 Edge）
@@ -1309,55 +1257,102 @@ export async function handleScoreAll(parsed) {
           throw new Error("no videos returned (network/captcha/slow-load)");
         }
 
-        // enrich: webserver API 或本地 HTTP view-source
-        if (webserver) {
+        // 国家识别率阈值：低于则等待后重新识别国家（复用同一批视频，不重抓列表）
+        const COUNTRY_RATE_MIN =
+          parseFloat(process.env.TAG_SCOREALL_MIN_COUNTRY_RATE || "0.8") || 0.8;
+        const COUNTRY_RETRY_WAIT_MS =
+          parseInt(
+            process.env.TAG_SCOREALL_COUNTRY_RETRY_WAIT_MS || "120000",
+            10,
+          ) || 120000;
+        const COUNTRY_MAX_RETRIES = Math.max(
+          0,
+          parseInt(process.env.TAG_SCOREALL_COUNTRY_MAX_RETRIES || "2", 10) ||
+            2,
+        );
+
+        let countryRetries = 0;
+        let rate = 0;
+        while (true) {
+          // enrich: webserver API 或本地 HTTP view-source
+          if (webserver) {
+            // 只补尚未识别到国家的视频，已有国家的不重复查
+            const pendingVideos = videos.filter((v) => !v.locationCreated);
+            if (pendingVideos.length > 0) {
+              log(
+                `  ⏳ 补充国家信息 (${pendingVideos.length} 个待补视频, via webserver ${webserver})...`,
+              );
+              await enrichViaWebserver(
+                pendingVideos,
+                webserver,
+                ({ done, total, current, locationCreated }) => {
+                  if (done % 10 === 0 || done === total) {
+                    const name = current.split("/").pop().slice(0, 20);
+                    process.stderr.write(
+                      `\r    [${done}/${total}] ${name} → ${locationCreated || "-"}\x1b[K`,
+                    );
+                  }
+                },
+              );
+              process.stderr.write("\n");
+            }
+          } else {
+            // enrich: 先查服务端缓存，只对未知视频发 HTTP 请求
+            const enriched = await enrichWithServerCache(
+              videos,
+              baseUrl,
+              enrichScraper,
+              {
+                clientId,
+                clientMeta,
+                effectiveProxy,
+                log,
+              },
+            );
+            videos = enriched.videos;
+
+            // CDN 限流检测：有拦截则冷却 + 重启 scraper
+            const cdnBlocked = enriched.cdnBlockedCount || 0;
+            if (cdnBlocked > 0) {
+              const cdnRatio = cdnBlocked / (videos.length || 1);
+              const coolSec = cdnRatio > 0.3 ? 120 : 60;
+              log(
+                `  ⚠️ CDN 限流: ${cdnBlocked}/${videos.length} (${(cdnRatio * 100).toFixed(0)}%)，冷却 ${coolSec} 秒后重启 scraper`,
+              );
+              await new Promise((r) => setTimeout(r, coolSec * 1000));
+              log(`  正在重启 TikTokScraper...`);
+              await enrichScraper.restart();
+              log(`  ✅ TikTokScraper 已重启`);
+            }
+          }
+
+          // 统计国家信息获取情况：多少视频真实拿到国家，多少没有
+          const withLoc = videos.filter((v) => v.locationCreated).length;
+          const withoutLoc = videos.length - withLoc;
+          rate = videos.length > 0 ? withLoc / videos.length : 0;
           log(
-            `  ⏳ 补充国家信息 (${videos.length} 个视频, via webserver ${webserver})...`,
-          );
-          await enrichViaWebserver(
-            videos,
-            webserver,
-            ({ done, total, current, locationCreated }) => {
-              if (done % 10 === 0 || done === total) {
-                const name = current.split("/").pop().slice(0, 20);
-                process.stderr.write(
-                  `\r    [${done}/${total}] ${name} → ${locationCreated || "-"}\x1b[K`,
-                );
-              }
-            },
+            `  ✓ 国家信息: ${withLoc} 个有国家 / ${withoutLoc} 个未获取到（共 ${videos.length}，识别率 ${(rate * 100).toFixed(0)}%）`,
           );
-          process.stderr.write("\n");
+
+          if (rate >= COUNTRY_RATE_MIN) break;
+          if (countryRetries >= COUNTRY_MAX_RETRIES) break;
+
+          countryRetries++;
           log(
-            `  ✓ 国家信息: ${videos.filter((v) => v.locationCreated).length}/${videos.length} 个视频有国家`,
-          );
-        } else {
-          // enrich: 先查服务端缓存，只对未知视频发 HTTP 请求
-          const enriched = await enrichWithServerCache(
-            videos,
-            baseUrl,
-            enrichScraper,
-            {
-              clientId,
-              clientMeta,
-              effectiveProxy,
-              log,
-            },
+            `  ⚠️ 国家识别率 ${(rate * 100).toFixed(0)}% < ${(COUNTRY_RATE_MIN * 100).toFixed(0)}%，等待 ${Math.round(COUNTRY_RETRY_WAIT_MS / 1000)} 秒后重新识别国家（第 ${countryRetries}/${COUNTRY_MAX_RETRIES} 次）...`,
           );
-          videos = enriched.videos;
+          await new Promise((r) => setTimeout(r, COUNTRY_RETRY_WAIT_MS));
+        }
 
-          // CDN 限流检测：有拦截则冷却 + 重启 scraper
-          const cdnBlocked = enriched.cdnBlockedCount || 0;
-          if (cdnBlocked > 0) {
-            const cdnRatio = cdnBlocked / (videos.length || 1);
-            const coolSec = cdnRatio > 0.3 ? 120 : 60;
-            log(
-              `  ⚠️ CDN 限流: ${cdnBlocked}/${videos.length} (${(cdnRatio * 100).toFixed(0)}%)，冷却 ${coolSec} 秒后重启 scraper`,
-            );
-            await new Promise((r) => setTimeout(r, coolSec * 1000));
-            log(`  正在重启 TikTokScraper...`);
-            await enrichScraper.restart();
-            log(`  ✅ TikTokScraper 已重启`);
-          }
+        // 重试耗尽仍低于阈值：跳过该标签，处理下一个任务
+        if (rate < COUNTRY_RATE_MIN) {
+          log(
+            `  ⏭️ 重试 ${COUNTRY_MAX_RETRIES} 次后国家识别率仍 ${(rate * 100).toFixed(0)}% < ${(COUNTRY_RATE_MIN * 100).toFixed(0)}%，跳过该标签，处理下一个`,
+          );
+          await recyclePage();
+          await maybeRecycleForMemory();
+          await randomDelay(3000, 7000);
+          continue;
         }
 
         // 过滤 + 算分 (共用函数)
@@ -1400,7 +1395,10 @@ export async function handleScoreAll(parsed) {
           `  ${icon} ${result.status} score=${result.score} authors=${result.authorCount} matched=${result.matchedAuthors} (${elapsed}s)${mc ? "  " + mc : ""}${memStr}`,
         );
         log("");
-        consecutive403 = 0; // 成功完成，重置 403 计数器
+        consecutiveTaskErrors = 0; // 成功完成，重置连续任务错误计数
+        retrySameTag = false; // 成功，不再重试
+        tag403Attempts = 0;
+        bannedCount = 0; // 成功 tag，重置连续判封计数
         // 每 10 个标签输出一次内存汇总
         if (totalScored % 10 === 0) {
           log(
@@ -1437,23 +1435,62 @@ export async function handleScoreAll(parsed) {
           (e.message.includes("HTTP 403") ||
             e.message.includes("status 403") ||
             e.message.includes("status code 403"));
+        const isCaptcha =
+          e.message &&
+          (e.message.includes("验证码") || e.message.includes("captcha"));
 
+        // ── 403：重试同一 tag，预算按判封次数递增 ──
         if (is403) {
-          consecutive403++;
+          tag403Attempts++;
+          const budget =
+            BAN_RETRY_BUDGETS[
+              Math.min(bannedCount, BAN_RETRY_BUDGETS.length - 1)
+            ];
+          if (tag403Attempts <= budget) {
+            retrySameTag = true;
+            log(
+              `  🚫 HTTP 403 (${tag403Attempts}/${budget}) — 重试同一 tag #${currentTag} ...`,
+            );
+            await recyclePage();
+            await randomDelay(2000, 5000);
+            continue;
+          }
+          // 重试耗尽：判定“被封”
+          bannedCount++;
           log(
-            `  🚫 HTTP 403 — 连续 ${consecutive403}/${CONSECUTIVE_403_BLOCKED} 次`,
+            `  🚫 重试 ${tag403Attempts} 次仍 403，判定账号被封（连续判封 ${bannedCount} 次）`,
           );
-        } else {
-          consecutive403 = 0;
+          if (bannedCount >= 2) {
+            log(`  ⚠️ 连续两次判封 → 汇报服务端 + 触发 daemon fallback`);
+            await reportClientErrorAndFailover({
+              post: (url, body) =>
+                fetch(url, {
+                  method: "POST",
+                  headers: buildClientHeaders(clientId, clientMeta, {
+                    "Content-Type": "application/json",
+                  }),
+                  body: JSON.stringify(body),
+                }),
+              baseUrl,
+              userId,
+              errorType: "consecutive_blocked",
+              message: `连续两次判定账号被封 (port=${cdpPort})`,
+              stage: "tag-scoring",
+              log,
+            });
+            bannedCount = 0;
+          }
+          retrySameTag = false;
+          tag403Attempts = 0;
+          await recyclePage();
+          await maybeRecycleForMemory();
+          await randomDelay(3000, 7000);
+          continue;
         }
 
+        // ── 非 403：保持原有错误处理 ──
         log(`  ❌ 失败: ${e.message}`);
 
-        // ── 验证码检测 ──
-        const isCaptcha =
-          e.message &&
-          (e.message.includes("验证码") || e.message.includes("captcha"));
-
         if (isCaptcha) {
           consecutiveCaptcha++;
           log(
@@ -1491,7 +1528,7 @@ export async function handleScoreAll(parsed) {
           } catch {}
 
           if (consecutiveCaptcha >= MAX_CONSECUTIVE_CAPTCHA) {
-            log(`  ♻️ 连续${MAX_CONSECUTIVE_CAPTCHA}次验证码 → 切换端口`);
+            log(`  ♻️ 连续${MAX_CONSECUTIVE_CAPTCHA}次验证码 → 重启浏览器`);
             await recycleCdpSession("连续验证码", { switchPort: true });
             consecutiveCaptcha = 0;
           }
@@ -1514,19 +1551,33 @@ export async function handleScoreAll(parsed) {
             clientMeta,
           );
         } catch {}
-        totalScored++;
 
-        // 连续 3 次 403：认为账号被封，等 2 分钟后切换端口
-        if (consecutive403 >= CONSECUTIVE_403_BLOCKED) {
+        // 连续任务错误达到阈值，上报服务端 + 触发 daemon fallback 换节点
+        consecutiveTaskErrors++;
+        if (consecutiveTaskErrors >= CONSECUTIVE_TASK_ERRORS_MAX) {
           log(
-            `  🔐 连续 ${consecutive403} 次 403，账号可能被封！等待 2 分钟后切换端口...`,
+            `  ⚠️ 连续任务错误 ${consecutiveTaskErrors}/${CONSECUTIVE_TASK_ERRORS_MAX} → 汇报服务端 + 触发 fallback`,
           );
-          await new Promise((r) => setTimeout(r, 120000));
-          await recycleCdpSession("连续 403 封禁");
-          consecutive403 = 0;
-          continue;
+          await reportConsecutiveTaskErrors({
+            post: (url, body) =>
+              fetch(url, {
+                method: "POST",
+                headers: buildClientHeaders(clientId, clientMeta, {
+                  "Content-Type": "application/json",
+                }),
+                body: JSON.stringify(body),
+              }),
+            baseUrl,
+            userId,
+            message: `连续 ${consecutiveTaskErrors} 个标签处理失败 (port=${cdpPort})`,
+            stage: "tag-scoring",
+            log,
+          });
+          consecutiveTaskErrors = 0;
         }
-
+        totalScored++;
+        retrySameTag = false;
+        tag403Attempts = 0;
         await recyclePage();
         await maybeRecycleForMemory();
       }

package/src/cli/webserver.js

@@ -11,6 +11,9 @@ export async function handleWebserver(options) {
     webserverProxy,
     webserverLog,
     webserverNotify,
+    webserverRate,
+    webserverBurst,
+    webserverCooldown,
   } = options;
 
   const { server, port } = await startWebserver(
@@ -19,6 +22,9 @@ export async function handleWebserver(options) {
     webserverProxy,
     webserverNotify,
     webserverLog,
+    webserverRate,
+    webserverBurst,
+    webserverCooldown,
   );
 
   let shuttingDown = false;

package/src/lib/api-interceptor-comment.js

@@ -57,8 +57,17 @@ async function fetchUserCommentsAPI(
     // 点击评论 tab 触发 API
     log("  [API拦截] 点击评论 tab...");
     const tabs = page.locator('[class*="tabbar-item"]');
-    const commentTab = tabs.filter({ hasText: /评论|Comment/ });
-    const count = await commentTab.count();
+
+    // 优先精确匹配：文本必须是"评论"或"Comment"，避免命中"商品/猜你喜欢/Shop/Related"等 tab
+    let commentTab = tabs.filter({ hasText: /^\s*(评论|Comment)\s*$/i });
+    let count = await commentTab.count();
+    if (count === 0) {
+      // 兜底：宽松匹配"评论|Comment"，但明确排除非评论 tab（商品/购物/猜你喜欢/推荐）
+      commentTab = tabs.filter({ hasText: /评论|Comment/ }).filter({
+        hasNotText: /商品|购物|带货|Shop|Shopping|橱窗|猜你喜欢|Related|推荐/i,
+      });
+      count = await commentTab.count();
+    }
 
     if (count === 0) {
       return {
@@ -69,6 +78,9 @@ async function fetchUserCommentsAPI(
       };
     }
 
+    // 只在候选只有一个/第一个确为评论 tab 时点击，避免点击到其它 tab
+    await commentTab.first().click({ force: true });
+
     await commentTab.first().click({ force: true });
 
     // 等待 API 响应

package/src/lib/args.js

@@ -412,6 +412,10 @@ function parseWebserverArgs(args) {
   let webserverPoolSize = 0;
   let webserverProxy = null;
   let webserverLog = false;
+  // 默认安全限速：3 请求/秒。限速突发容量自动跟随 pool-size（见下方返回）。
+  let webserverRate = 3;
+  // CDN 限流冷却时长（秒），默认 100（2 次重启 + 切节点流程节奏）
+  let webserverCooldown = 100;
   // 默认汇报到 ~/.tt-help.json 中配置的 server 地址
   let webserverNotify = defaultServer;
 
@@ -423,6 +427,22 @@ function parseWebserverArgs(args) {
       webserverPoolSize = parseInt(args[++i]) || 0;
     } else if (arg === "--proxy") {
       webserverProxy = args[++i] || null;
+    } else if (arg === "--rate") {
+      const next = args[i + 1];
+      if (next && !next.startsWith("--")) {
+        webserverRate = parseInt(next) || 0;
+        i++;
+      } else {
+        webserverRate = 3; // 缺省回退到安全默认值
+      }
+    } else if (arg === "--cooldown") {
+      const next = args[i + 1];
+      if (next && !next.startsWith("--")) {
+        webserverCooldown = parseInt(next) || 100;
+        i++;
+      } else {
+        webserverCooldown = 100; // 缺省回退到默认值
+      }
     } else if (arg === "--log") {
       webserverLog = true;
     } else if (arg === "--notify") {
@@ -443,6 +463,10 @@ function parseWebserverArgs(args) {
     webserverProxy,
     webserverLog,
     webserverNotify,
+    webserverRate,
+    // burst 自动跟随 pool-size：未显式指定时与最终生效的页面池大小一致
+    webserverBurst: webserverPoolSize > 0 ? webserverPoolSize : 8,
+    webserverCooldown,
     urls: [],
     outputFile: null,
     outputFormat: "json",