tt-help-cli-ycl 1.4.164 → 1.4.165

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tt-help-cli-ycl",
-  "version": "1.4.164",
+  "version": "1.4.165",
   "description": "TikTok user & video data scraper - extract ttSeller, verified, locationCreated from HTML source",
   "type": "module",
   "bin": {

package/scripts/test-clash-hysteresis.mjs

@@ -0,0 +1,131 @@
+/**
+ * 候选集迟滞（mergeHealthyWithHysteresis）单测（离线，不碰真实健康文件）
+ *
+ * 背景：delay 初测为单点采样，瞬时抖动会把健康节点误踢出池（2026-09-28 生产实锤：
+ * 英国节点被白名单守卫切回）。迟滞规则：连续 2 轮初测失败才除名；失败第 1 轮保留
+ * 在池内作"降级观察"，写盘顺序沉底（幸存者在前后降级在后，轮换优先实测存活节点）。
+ *
+ * 覆盖：
+ *   - 首轮（无上一轮池）→ 仅幸存者，无降级
+ *   - 本轮失败第 1 轮 → 保留 + 计数 1，排幸存者之后
+ *   - 连续第 2 轮失败（prevDegraded=1）→ 除名
+ *   - 降级后恢复 → 计数自动清零
+ *   - maxRounds=1 → 关闭迟滞（失败即除名）
+ *   - 容错：prev 非法值 / 空 prevDegraded
+ *   - 文件往返：saveHealthyList(degraded) → loadHealthyList 读回
+ *   - pruneHealthyListByCurrentProxies 剔除节点时携带留存节点的 degraded
+ *
+ * 运行: node scripts/test-clash-hysteresis.mjs
+ */
+import assert from "node:assert/strict";
+import { unlinkSync, existsSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import {
+  mergeHealthyWithHysteresis,
+  saveHealthyList,
+  loadHealthyList,
+  pruneHealthyListByCurrentProxies,
+  applyDiscovered,
+} from "../src/clash/checker.js";
+
+let passed = 0;
+const failures = [];
+async function check(name, fn) {
+  try {
+    await fn();
+    passed++;
+    console.log(`PASS ${name}`);
+  } catch (e) {
+    failures.push({ name, e });
+    console.log(`FAIL ${name}: ${e.message}`);
+  }
+}
+
+// ── 纯函数：mergeHealthyWithHysteresis ──
+
+await check("首轮（无上一轮池）→ 仅幸存者，无降级", () => {
+  const r = mergeHealthyWithHysteresis(["A", "B"], [], {}, 2);
+  assert.deepEqual(r.nodes, ["A", "B"]);
+  assert.deepEqual(r.degraded, {});
+});
+
+await check("本轮失败第 1 轮 → 保留 + 计数 1，排幸存者之后", () => {
+  // 上一轮池 [A,B,C]，本轮只有 A 可达：B/C 首次失败，保留观察
+  const r = mergeHealthyWithHysteresis(["A"], ["A", "B", "C"], {}, 2);
+  assert.deepEqual(r.nodes, ["A", "B", "C"]); // 幸存者在前、降级在后（B/C 保持原相对序）
+  assert.deepEqual(r.degraded, { B: 1, C: 1 });
+});
+
+await check("连续第 2 轮失败（prevDegraded=1）→ 除名", () => {
+  // B 上一轮已失败 1 次，本轮再失败 → 达到 maxRounds=2，除名；C 首次失败保留
+  const r = mergeHealthyWithHysteresis(["A"], ["A", "B", "C"], { B: 1 }, 2);
+  assert.deepEqual(r.nodes, ["A", "C"]);
+  assert.deepEqual(r.degraded, { C: 1 });
+  assert.ok(!("B" in r.degraded));
+});
+
+await check("降级后恢复 → 计数自动清零", () => {
+  // C 上轮降级（计数 1），本轮恢复 → 回到幸存者区，degraded 中无 C；
+  // B 本轮首次失败，照常保留观察
+  const r = mergeHealthyWithHysteresis(
+    ["A", "C"],
+    ["A", "B", "C"],
+    { C: 1 },
+    2,
+  );
+  assert.deepEqual(r.nodes, ["A", "C", "B"]);
+  assert.deepEqual(r.degraded, { B: 1 });
+});
+
+await check("maxRounds=1 → 关闭迟滞（失败即除名）", () => {
+  const r = mergeHealthyWithHysteresis(["A"], ["A", "B"], {}, 1);
+  assert.deepEqual(r.nodes, ["A"]);
+  assert.deepEqual(r.degraded, {});
+});
+
+await check("容错：prev 非法 / prevDegraded 非法", () => {
+  const r = mergeHealthyWithHysteresis(["A"], null, "bad", 2);
+  assert.deepEqual(r.nodes, ["A"]);
+  assert.deepEqual(r.degraded, {});
+});
+
+// ── 文件往返（隔离端口通道，不碰真实 clash-healthy-nodes.json） ──
+
+const TEST_PORT = 64000 + Math.floor(Math.random() * 1000);
+const TEST_FILE = join(tmpdir(), `clash-healthy-nodes-${TEST_PORT}.json`);
+applyDiscovered({ proxyPort: TEST_PORT });
+
+try {
+  await check("saveHealthyList(degraded) → loadHealthyList 读回", () => {
+    saveHealthyList(
+      ["🇺🇸美国HY1", "🇬🇧英国HY1"],
+      { "🇺🇸美国HY1": 800 },
+      { "🇬🇧英国HY1": 1 },
+    );
+    const d = loadHealthyList();
+    assert.deepEqual(d.nodes, ["🇺🇸美国HY1", "🇬🇧英国HY1"]);
+    assert.equal(d.delays["🇺🇸美国HY1"], 800);
+    assert.equal(d.degraded["🇬🇧英国HY1"], 1);
+  });
+
+  await check("pruneHealthyListByCurrentProxies 携带留存节点的 degraded", () => {
+    // 内核中只剩美国节点：英国被剔除，美国的降级计数（若有）应保留
+    saveHealthyList(
+      ["🇺🇸美国HY1", "🇺🇸美国HY2", "🇬🇧英国HY1"],
+      { "🇺🇸美国HY1": 800 },
+      { "🇺🇸美国HY2": 1, "🇬🇧英国HY1": 1 },
+    );
+    const r = pruneHealthyListByCurrentProxies(["🇺🇸美国HY1", "🇺🇸美国HY2"]);
+    assert.equal(r.removed, 1);
+    const d = loadHealthyList();
+    assert.deepEqual(d.nodes, ["🇺🇸美国HY1", "🇺🇸美国HY2"]);
+    assert.equal(d.degraded["🇺🇸美国HY2"], 1);
+    assert.ok(!("🇬🇧英国HY1" in d.degraded));
+  });
+} finally {
+  if (existsSync(TEST_FILE)) unlinkSync(TEST_FILE);
+}
+
+console.log(`\n结果: ${passed} 通过, ${failures.length} 失败`);
+if (failures.length) process.exit(1);

package/scripts/test-client-error-monitor.mjs

@@ -1,10 +1,12 @@
 /**
- * 客户端异常监控单测（2026-08-28）
+ * 客户端异常监控单测（2026-08-28，2026-09-28 增补验证码路径）
  *
  * 验证：
- *   - detectClientError 检测函数：reportCount > 8 且最近一次上报在 2 分钟内
+ *   - detectClientError 检测函数：
+ *     A. reportCount > 8 且最近一次上报在 2 分钟内
+ *     B. captchaCount ≥ 3（webserver 验证码上报，10 分钟过期窗口内累计）
  *   - 按 hostname 过滤本机条目；hostname 为空的旧条目不参与关联
- *   - 命中 → onAlert 收到本机全部条目（含未命中条目）；未命中 → 不回调
+ *   - 命中 → onAlert 收到本机全部条目与命中列表；未命中 → 不回调
  *   - removeErrors 逐条 DELETE 并计数
  *
  * 运行: node --test scripts/test-client-error-monitor.mjs
@@ -60,6 +62,79 @@ test("D4 detectClientError：缺 reportCount → 不命中", () => {
   assert.equal(detectClientError({ timestamp: Date.now() }, Date.now()), false);
 });
 
+// ── 验证码路径（captchaCount ≥ 3） ──
+
+test("C1 detectClientError：captchaCount=3 → 命中", () => {
+  assert.equal(
+    detectClientError(
+      makeErr({ reportCount: 0, captchaCount: 3 }),
+      Date.now(),
+    ),
+    true,
+  );
+});
+
+test("C2 detectClientError：captchaCount=2 不命中（阈值是 ≥3）", () => {
+  assert.equal(
+    detectClientError(
+      makeErr({ reportCount: 0, captchaCount: 2 }),
+      Date.now(),
+    ),
+    false,
+  );
+});
+
+test("C3 detectClientError：captchaCount=3 但最近上报超 2 分钟 → 不命中", () => {
+  assert.equal(
+    detectClientError(
+      makeErr({
+        reportCount: 0,
+        captchaCount: 3,
+        timestamp: Date.now() - 2 * 60_000 - 1,
+      }),
+      Date.now(),
+    ),
+    false,
+  );
+});
+
+test("C4 detectClientError：reportCount 未达标 + captchaCount 达标 → 命中", () => {
+  assert.equal(
+    detectClientError(
+      makeErr({ reportCount: 1, captchaCount: 5 }),
+      Date.now(),
+    ),
+    true,
+  );
+});
+
+test("C5 监控器：验证码条目命中 → onAlert 收到命中列表", async () => {
+  const captchaHit = makeErr({
+    userId: "webserver-host",
+    reportCount: 0,
+    captchaCount: 3,
+  });
+  const businessMiss = makeErr({ userId: "u-task", reportCount: 2 });
+  mock.method(globalThis, "fetch", async () => ({
+    ok: true,
+    json: async () => ({ clients: [captchaHit, businessMiss] }),
+  }));
+  let received = null;
+  const m = new ClientErrorMonitor({
+    serverUrl: "http://127.0.0.1:3000",
+    hostname: HOST,
+    onAlert: async (mine, hit) => {
+      received = { mine, hit };
+    },
+  });
+  const hit = await m._poll();
+  assert.equal(hit.length, 1, "仅验证码条目命中");
+  assert.equal(hit[0].userId, "webserver-host");
+  assert.equal(received.hit.length, 1);
+  assert.equal(received.mine.length, 2, "回调同时携带本机未命中条目");
+  mock.restoreAll();
+});
+
 // ── 监控器 ──
 
 test("M1 按 hostname 过滤：他机条目不触发本机回调", async () => {

package/scripts/test-webserver-error-classify.mjs

@@ -244,6 +244,36 @@ check("switchClashNode：选第一个 delay 通过的候选并切换", async ()
   }
 });
 
+check("switchClashNode：批量测速（/group/{G}/delay）优先且覆盖候选时不逐个探测", async () => {
+  let switchedTo = null;
+  let perNodeDelayCalls = 0;
+  const server = await startMockClash((req, url, body, reply) => {
+    if (req.method === "GET" && url.pathname === "/proxies/GLOBAL") {
+      reply(200, { now: "A", all: ["A", "B", "C"] });
+    } else if (req.method === "GET" && url.pathname === "/group/GLOBAL/delay") {
+      reply(200, { B: 88, C: 999 });
+    } else if (req.method === "GET" && url.pathname.endsWith("/delay")) {
+      perNodeDelayCalls++; // 批量可用时不应走到这里
+      reply(200, { delay: 120, timeout: false });
+    } else if (req.method === "PUT" && url.pathname === "/proxies/GLOBAL") {
+      switchedTo = body.name;
+      reply(204);
+    } else {
+      reply(404, {});
+    }
+  });
+  configure({ port: server.address().port });
+  try {
+    const picked = await switchClashNode("测试批量优先");
+    assert.equal(picked, "B");
+    assert.equal(switchedTo, "B");
+    assert.equal(perNodeDelayCalls, 0);
+  } finally {
+    resetConfig();
+    await new Promise((r) => server.close(r));
+  }
+});
+
 check("switchClashNode：候选均探测不通 → 抛错", async () => {
   const server = await startMockClash((req, url, body, reply) => {
     if (req.method === "GET" && url.pathname === "/proxies/GLOBAL") {

package/src/clash/checker.js

@@ -461,17 +461,23 @@ export function loadHealthyList(country = null) {
       isUsableProxyNode,
     );
     const allDelays = d.delays && typeof d.delays === "object" ? d.delays : {};
+    const degradedRaw =
+      d.degraded && typeof d.degraded === "object" ? d.degraded : {};
     const filter = country || CONFIG.nodeCountryFilter;
     const { filtered, excluded } = filterNodesByCountry(allNodes, filter);
     const delays = {};
+    const degraded = {};
     for (const n of filtered) {
       const v = allDelays[n];
       if (typeof v === "number" && v > 0) delays[n] = v;
+      const g = degradedRaw[n];
+      if (typeof g === "number" && g > 0) degraded[n] = g;
     }
     return {
       updated: d.updated || "",
       nodes: filtered,
       delays,
+      degraded,
       totalNodes: allNodes.length,
       excluded,
       countryFilter: filter || null,
@@ -482,12 +488,17 @@ export function loadHealthyList(country = null) {
   return _emptyList();
 }
 
-export function saveHealthyList(nodes, delays = {}) {
+export function saveHealthyList(nodes, delays = {}, degraded = {}) {
   try {
     writeFileSync(
       _healthyFile,
       JSON.stringify(
-        { updated: new Date().toISOString(), nodes, delays: delays || {} },
+        {
+          updated: new Date().toISOString(),
+          nodes,
+          delays: delays || {},
+          degraded: degraded || {},
+        },
         null,
         2,
       ),
@@ -498,6 +509,42 @@ export function saveHealthyList(nodes, delays = {}) {
   }
 }
 
+/**
+ * 候选集迟滞合并（纯函数，便于单测）
+ *
+ * 背景：delay 初测为单点采样，瞬时抖动会把健康节点误踢出池（2026-09-28 生产实锤：
+ * 英国节点被白名单守卫切回）。规则：连续 maxRounds 轮初测失败才除名；失败第 1 轮
+ * 保留在池内作"降级观察"，且排在幸存者之后（写盘顺序即沉底，轮换优先尝试实测存活节点）。
+ *
+ * @param {string[]} survivors 本轮初测幸存者（delay ≤ 阈值，升序）
+ * @param {string[]} prevNodes 上一轮池内节点（含上轮降级保留）
+ * @param {Record<string,number>} prevDegraded 上一轮降级计数 {node: 连续失败轮数}
+ * @param {number} maxRounds 连续失败轮数上限（达到即除名），默认 2；1 = 关闭迟滞
+ * @returns {{nodes: string[], degraded: Record<string, number>}} 合并后的池
+ *   （幸存者在前、降级保留在后）与新降级计数；本轮恢复的节点计数自动清零
+ */
+export function mergeHealthyWithHysteresis(
+  survivors,
+  prevNodes,
+  prevDegraded = {},
+  maxRounds = 2,
+) {
+  const list = Array.isArray(survivors) ? survivors : [];
+  const survivorSet = new Set(list);
+  const degraded = {};
+  const retained = [];
+  for (const n of Array.isArray(prevNodes) ? prevNodes : []) {
+    if (survivorSet.has(n)) continue; // 本轮存活：不进新 degraded，计数自动清零
+    const fails = (Number(prevDegraded[n]) || 0) + 1;
+    if (fails < maxRounds) {
+      degraded[n] = fails;
+      retained.push(n);
+    }
+    // fails >= maxRounds：连续多轮失败，确认除名
+  }
+  return { nodes: [...list, ...retained], degraded };
+}
+
 /**
  * 剔除候选集中已不在当前内核配置中的节点（订阅切换 / 订阅更新场景）
  *
@@ -516,6 +563,8 @@ export function pruneHealthyListByCurrentProxies(validNames) {
     const d = JSON.parse(readFileSync(_healthyFile, "utf-8"));
     const allNodes = Array.isArray(d.nodes) ? d.nodes : [];
     const allDelays = d.delays && typeof d.delays === "object" ? d.delays : {};
+    const degradedRaw =
+      d.degraded && typeof d.degraded === "object" ? d.degraded : {};
     const valid = new Set(validNames);
     const keptNodes = allNodes.filter((n) => valid.has(n));
     const removed = allNodes.length - keptNodes.length;
@@ -523,11 +572,14 @@ export function pruneHealthyListByCurrentProxies(validNames) {
       return { kept: keptNodes.length, removed: 0, allGone: false };
     }
     const keptDelays = {};
+    const keptDegraded = {};
     for (const n of keptNodes) {
       const v = allDelays[n];
       if (typeof v === "number" && v > 0) keptDelays[n] = v;
+      const g = degradedRaw[n];
+      if (typeof g === "number" && g > 0) keptDegraded[n] = g;
     }
-    saveHealthyList(keptNodes, keptDelays);
+    saveHealthyList(keptNodes, keptDelays, keptDegraded);
     return {
       kept: keptNodes.length,
       removed,
@@ -544,6 +596,7 @@ function _emptyList() {
     updated: "",
     nodes: [],
     delays: {},
+    degraded: {},
     totalNodes: 0,
     excluded: 0,
     countryFilter: null,

package/src/clash/daemon.js

@@ -24,6 +24,10 @@ function fmtCountries(v) {
 // failover 冷却期（默认 10 分钟，与候选集 delay 初测周期对齐；可经 opts.failoverCooldownMs 覆盖）
 // 锚点 = 最近一次实际切换节点的时间（_lastSwitchAt）：冷却期内探针健康不切换
 const FAILOVER_COOLDOWN_MS = 600_000;
+// 候选集迟滞（2026-09-28）：delay 初测为单点采样，瞬时抖动会把健康节点误踢出池
+// （生产实锤：英国节点被白名单守卫切回）。连续 PROBE_HYSTERESIS_ROUNDS 轮初测失败
+// 才除名；失败第 1 轮保留在池内作"降级观察"，写盘时排在幸存者之后（轮换优先实测存活）
+const PROBE_HYSTERESIS_ROUNDS = 2;
 // 已弃用（2026-08-25 改为时间锚点方案）：旧版"窗口内连报 N 次"计数，字段保留仅为兼容外部传参
 const FAILOVER_ESCAPE_AFTER = 3;
 
@@ -972,10 +976,20 @@ export class ClashDaemon {
         if (typeof it.delay === "number" && it.delay > 0)
           delays[it.node] = it.delay;
       }
-      checker.saveHealthyList(r.nodes, delays);
+      // 迟滞合并：本轮失败的上一轮池内节点保留一轮观察（降级沉底），
+      // 连续 PROBE_HYSTERESIS_ROUNDS 轮失败才除名；恢复的节点计数自动清零
+      const prev = checker.loadHealthyList();
+      const merged = checker.mergeHealthyWithHysteresis(
+        r.nodes,
+        prev.nodes,
+        prev.degraded,
+        PROBE_HYSTERESIS_ROUNDS,
+      );
+      checker.saveHealthyList(merged.nodes, delays, merged.degraded);
+      const retainedCount = merged.nodes.length - r.nodes.length;
       // 清理切换历史中已不在候选集的节点，防止 Map 无限增长
       if (c._switchHistory && c._switchHistory.size) {
-        const keep = new Set(r.nodes);
+        const keep = new Set(merged.nodes);
         for (const k of [...c._switchHistory.keys()]) {
           if (!keep.has(k)) c._switchHistory.delete(k);
         }
@@ -985,7 +999,7 @@ export class ClashDaemon {
       c._meta.healthyNodesCount = r.nodes.length;
       if (r.nodes.length) {
         this._log(
-          `=== [${c.proxyPort}] delay 初测完成 (${elapsed}s): ${r.nodes.length} 个可达节点 ===`,
+          `=== [${c.proxyPort}] delay 初测完成 (${elapsed}s): ${r.nodes.length} 个可达${retainedCount ? `（另降级保留 ${retainedCount} 个）` : ""} ===`,
         );
       } else {
         this._log(

package/src/clash/proxy-switch.js

@@ -37,12 +37,16 @@ export function isDaemonAlive(port = 0) {
  * @param {string} reason 切换原因
  * @param {number} [proxyPort] 代理通道端口（0=默认通道）
  * @param {number} [waitMs] 等待毫秒数，默认 30000
+ * @param {object} [opts]
+ * @param {boolean} [opts.force] 强切（无视 daemon failover 冷却期直接轮换）；
+ *   供调用方已自行节流的场景（如 webserver CDN 自愈：100s 冷却+5min 窗口+次数上限）
  * @returns {boolean} 是否发起了切换（有代理端口）
  */
 export async function triggerProxySwitch(
   reason,
   proxyPort = 0,
   waitMs = DEFAULT_SWITCH_WAIT_MS,
+  { force = false } = {},
 ) {
   if (!proxyPort) {
     console.error(`  [代理] 未配置代理，跳过切换（${reason}）`);
@@ -57,7 +61,7 @@ export async function triggerProxySwitch(
     `  [代理] 触发切换（${reason}，通道 ${proxyPort}），等待 ${Math.round(waitMs / 1000)}s 生效...`,
   );
   writeCommand(
-    { action: "failover", reason: `proxy-switch: ${reason}`, proxyPort },
+    { action: "failover", reason: `proxy-switch: ${reason}`, proxyPort, force },
     proxyPort,
   );
   await new Promise((r) => setTimeout(r, waitMs));

package/src/clash/runtime.js

@@ -15,7 +15,7 @@
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync, statSync, readdirSync, copyFileSync, openSync, renameSync, lstatSync, symlinkSync } from "fs";
 import net from "net";
-import { homedir, platform, arch } from "os";
+import { homedir, platform, arch, tmpdir } from "os";
 import { join, dirname } from "path";
 import { spawn, spawnSync, execSync } from "child_process";
 import { gunzipSync } from "zlib";
@@ -681,6 +681,13 @@ export async function stopRuntimeInstance(index = 1, { log = () => {} } = {}) {
       } catch {}
     }
   }
+  if (killed) {
+    // 回收成功 → 一并清理通道健康文件，避免幽灵通道残留
+    //（daemon _rediscover 后不再巡检该实例，文件永远不会被覆盖，看门狗页面会多出幽灵订阅）
+    try {
+      rmSync(join(tmpdir(), `clash-health-${spec.mixedPort}.json`), { force: true });
+    } catch {}
+  }
   return killed;
 }
 

package/src/lib/browser/cdp.js

@@ -222,6 +222,92 @@ function killEdgeProcesses(targetDir, port) {
   });
 }
 
+/**
+ * 查找"残留" Edge 主进程：命令行包含指定 user-data-dir、但不带
+ * --remote-debugging-port（Edge 自动更新/崩溃自恢复、上次强杀残留等，
+ * 占着 profile 却没监听 CDP 端口）。
+ * 排除带 --type= 的子进程：渲染进程等子进程同样带 user-data-dir 却没有
+ * CDP 参数，误杀会打断同 profile 的健康实例。
+ *
+ * 这类实例必须先杀掉再启动：否则新 msedge 会因 Chromium ProcessSingleton
+ * 把命令行转发给旧实例，变成"旧实例开一个 about:blank 新 tab"，CDP 端口
+ * 永远起不来 → 等待超时 → watchdog 自动重启 → 每轮再开一个 tab。
+ *
+ * killEdgeProcesses 在 Windows 上按监听端口找 PID，对这类实例无效，
+ * 故单独按命令行匹配精确清理。
+ *
+ * @param {string} targetDir - user-data-dir 路径
+ * @returns {string[]|null} PID 列表；无法枚举进程命令行（PowerShell/WMI 不可用）时返回 null
+ */
+function findStaleEdgePids(targetDir) {
+  const platform = os.platform();
+  try {
+    let out;
+    if (platform === "win32") {
+      // PowerShell 为主（wmic 已从新版 Win11 移除；项目其他模块同样依赖 PowerShell）
+      out = decodeWinOutput(
+        execSync(
+          'powershell -NoProfile -Command "Get-CimInstance Win32_Process | Where-Object { $_.Name -eq \'msedge.exe\' } | ForEach-Object { Write-Output ($_.ProcessId.ToString() + \'|\' + $_.CommandLine) }"',
+          { encoding: "buffer", timeout: 10000, windowsHide: true },
+        ),
+      );
+    } else {
+      out = execSync("ps -eo pid,args", {
+        encoding: "utf-8",
+        timeout: 10000,
+      });
+    }
+    const dirLower = targetDir.toLowerCase();
+    const pids = [];
+    for (const line of out.split(/\r?\n/)) {
+      const lower = line.toLowerCase();
+      if (!lower.includes(dirLower)) continue; // 只匹配本 profile
+      // 边界保护：避免 _p9222 误匹配 _p92221 这类前缀目录
+      const idx = lower.indexOf(dirLower);
+      const next = lower[idx + dirLower.length];
+      if (next && /[a-z0-9_]/.test(next)) continue;
+      if (lower.includes("remote-debugging-port")) continue; // 健康 CDP 实例，不动
+      if (lower.includes("--type=")) continue; // 子进程，误杀会打断健康实例
+      // 提取 PID：win 格式 "PID|命令行"，unix 格式 "  PID 命令行"
+      const m = line.match(/^\s*(\d+)(?:\||\s)/);
+      if (m && !pids.includes(m[1])) pids.push(m[1]);
+    }
+    return pids;
+  } catch (e) {
+    console.error(`[findStaleEdgePids] 枚举 Edge 进程失败: ${e.message}`);
+    return null;
+  }
+}
+
+/**
+ * 强杀指定 PID 的 Edge 进程树（Windows 用 taskkill /T 保级联，其余平台 kill -9）。
+ * @param {string[]} pids
+ * @returns {Promise<void>}
+ */
+function killEdgeStale(pids) {
+  const platform = os.platform();
+  if (platform === "win32") {
+    const killCmds = pids.map((pid) => `taskkill /F /T /PID ${pid}`).join(" & ");
+    try {
+      const out = execSync(`(${killCmds})`, {
+        encoding: "buffer",
+        timeout: 15000,
+        windowsHide: true,
+      });
+      const lines = decodeWinOutput(out).split(/\r?\n/).filter(Boolean);
+      console.error(
+        `[killEdgeStale] taskkill 结果: ${lines.join(" | ") || "(无输出)"}`,
+      );
+    } catch (e) {
+      console.error(`[killEdgeStale] taskkill 失败: ${e.message}`);
+    }
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    exec(`kill -9 ${pids.join(" ")} 2>/dev/null; true`, () => resolve());
+  });
+}
+
 function launchEdgeWithCDP(port, userDataDir, proxyServer) {
   return new Promise((resolve, reject) => {
     const platform = os.platform();
@@ -319,10 +405,27 @@ export async function ensureBrowserReady(options = {}) {
         console.error(`CDP 端口 ${port} 未就绪，正在启动 Edge 浏览器...`);
       }
     }
+    // 残留实例清理：占着该 user-data-dir 却没开 CDP 的旧 Edge 必须先杀掉，
+    // 否则 launch 会被 ProcessSingleton 转发成"旧实例开新 tab"，CDP 永远起不来。
+    const stalePids = findStaleEdgePids(userDataDir);
+    if (stalePids === null) {
+      console.error("[浏览器] 无法枚举 Edge 进程命令行，跳过残留实例检测");
+    } else if (stalePids.length > 0) {
+      console.error(
+        `[浏览器] 检测到占用 ${path.basename(userDataDir)} 但未开 CDP 的残留 Edge 实例 (PID: ${stalePids.join(", ")})，正在清理...`,
+      );
+      await killEdgeStale(stalePids);
+      await new Promise((r) => setTimeout(r, 3000));
+    }
+
     await launchEdgeWithCDP(port, userDataDir, proxyServer);
 
     console.error("等待浏览器启动...");
-    const launched = await waitForCDP(port);
+    // Windows 冷启动（杀软扫描/更新后首次启动）可能超过 30s，放宽到 60s
+    const launched = await waitForCDP(
+      port,
+      os.platform() === "win32" ? 60000 : 30000,
+    );
     if (!launched) {
       throw new Error(
         `等待 CDP 端口 ${port} 超时。请确认 Edge 浏览器已安装，\n` +

package/src/watch/public/app.js

@@ -5316,6 +5316,8 @@ function renderProxySection(c, userId) {
     }
     var html = renderSubsOverview(c, userId, builtin, channels);
     for (var j = 0; j < external.length; j++) {
+      // 幽灵外部通道（>2min 未更新的残留健康文件）不渲染
+      if (external[j].stale) continue;
       // 外部通道的订阅配置入口：仅当没有总览区时显示（配置入口全局收敛为一个）
       html += renderExternalChannel(external[j], userId, !html);
     }
@@ -5391,6 +5393,8 @@ function renderSubsOverview(c, userId, builtinChannels, allChannels) {
   }
   var count = configured.length;
   for (var p in byPort) {
+    // 幽灵通道（实例已回收但健康文件残留，>2min 未更新）不得撑大订阅数
+    if (byPort[p] && byPort[p].stale) continue;
     var n = parseInt(p, 10) - _SUBS_BASE_PROXY_PORT + 1;
     if (n > count) count = n;
   }

package/src/watchdog/agent.js

@@ -27,7 +27,10 @@ import { join, dirname } from "path";
 import { homedir, tmpdir, hostname as osHostname } from "os";
 import { fileURLToPath } from "url";
 import { pushSelfLog, getSelfLogs } from "./self-log-buffer.js";
-import { ClientErrorMonitor } from "./client-error-monitor.js";
+import {
+  ClientErrorMonitor,
+  DETECT_CAPTCHA_COUNT_THRESHOLD,
+} from "./client-error-monitor.js";
 import { takeoverEnvironment } from "./env-init.js";
 
 // ── 看门狗自身日志入环（供后台页面按需拉取，经 report-logs 回传落盘） ──
@@ -719,7 +722,8 @@ export class WatchdogAgent {
 
   /**
    * 启动客户端异常监控：定时拉取 watch 服务端异常列表，
-   * 命中本机条目（reportCount > 8 且最近 2 分钟内）→ 强切代理 + 删除全部本机条目。
+   * 命中本机条目（reportCount > 8 或 captchaCount ≥ 3，且最近 2 分钟内）
+   * → 强切代理 + 删除命中条目（防下一轮轮询重复强切）。
    */
   _startClientErrorMonitor() {
     const cfg = getClientConfig();
@@ -734,16 +738,24 @@ export class WatchdogAgent {
       serverUrl: server,
       hostname: osHostname(),
       intervalMs: 60_000,
-      onAlert: async (mine) => {
-        const ids = mine.map((e) => e.userId).join(",");
-        console.error(
-          `[watchdog] 客户端异常监控命中 ${mine.length} 条本机异常 (${ids})，强制切换代理并清理`,
+      onAlert: async (mine, hit) => {
+        const ids = hit.map((e) => e.userId).join(",");
+        // 验证码计数与业务错误累计共用监控通道，强切原因区分便于排障
+        const hasCaptcha = hit.some(
+          (e) =>
+            typeof e.captchaCount === "number" &&
+            e.captchaCount >= DETECT_CAPTCHA_COUNT_THRESHOLD,
         );
-        await this._forceFailover("client-errors");
-        const removed = await this.clientErrorMonitor.removeErrors(mine);
         console.error(
-          `[watchdog] 已清理本机异常条目 ${removed}/${mine.length}`,
+          `[watchdog] 客户端异常监控命中 ${hit.length} 条本机异常 (${ids})${hasCaptcha ? " [含验证码]" : ""}，强制切换代理并清理`,
+        );
+        await this._forceFailover(
+          hasCaptcha ? "client-captcha" : "client-errors",
         );
+        // 仅清理命中条目：命中条目留存会持续满足阈值 → 下轮轮询重复强切；
+        // 未命中的本机条目（计数未达标）保留继续累计
+        const removed = await this.clientErrorMonitor.removeErrors(hit);
+        console.error(`[watchdog] 已清理命中异常条目 ${removed}/${hit.length}`);
       },
     });
     this.clientErrorMonitor.start();

package/src/watchdog/client-error-monitor.js

@@ -7,26 +7,46 @@
  *   3. 逐条过独立检测函数，命中 → onAlert(本机全部条目, 命中条目)
  *   4. 提供 removeErrors 删除接口（处理完成后的清理）
  *
- * 检测函数第一版：reportCount > 8 且最近一次上报在 2 分钟内。
+ * 检测函数（两条命中路径，满足任一即命中）：
+ *   A. reportCount > 8（非验证码业务错误累计）且最近一次上报在 2 分钟内
+ *   B. captchaCount ≥ 3（webserver 验证码上报，服务端 10 分钟过期窗口内累计）
  */
 
 import os from "os";
 
-/** 检测阈值：累计上报次数 > 8 */
+/** 检测阈值：非验证码错误累计上报次数 > 8 */
 export const DETECT_REPORT_COUNT_THRESHOLD = 8;
+/** 检测阈值：验证码次数 ≥ 3（10 分钟过期窗口内 3 次独立验证码事件） */
+export const DETECT_CAPTCHA_COUNT_THRESHOLD = 3;
 /** 检测窗口：最近一次上报距今 < 2 分钟 */
 export const DETECT_FRESH_MS = 2 * 60 * 1000;
 
 /**
- * 独立检测函数（第一版）
+ * 独立检测函数
  * @param {object} err - /api/client-errors 返回的单条异常
  * @param {number} [now] - 当前时间戳（测试注入用）
  * @returns {boolean}
  */
 export function detectClientError(err, now = Date.now()) {
-  if (!err || typeof err.reportCount !== "number") return false;
+  if (!err || typeof err.timestamp !== "number") return false;
   const fresh = now - err.timestamp < DETECT_FRESH_MS;
-  return err.reportCount > DETECT_REPORT_COUNT_THRESHOLD && fresh;
+  if (!fresh) return false;
+  // 路径 A：非验证码业务错误累计
+  if (
+    typeof err.reportCount === "number" &&
+    err.reportCount > DETECT_REPORT_COUNT_THRESHOLD
+  ) {
+    return true;
+  }
+  // 路径 B：验证码计数达标（每次验证码上报都刷新 timestamp，达标时必然新鲜，
+  // freshness 主要防陈旧累计延迟触发）
+  if (
+    typeof err.captchaCount === "number" &&
+    err.captchaCount >= DETECT_CAPTCHA_COUNT_THRESHOLD
+  ) {
+    return true;
+  }
+  return false;
 }
 
 /**

package/src/webserver/server.mjs

@@ -8,8 +8,17 @@ import {
   getCurrentNode,
   listGroupNodes,
   getProxyDelay,
+  getGroupDelay,
   switchProxy,
+  configure as configureClashApi,
 } from "../clash/api.js";
+import { isUsableProxyNode } from "../clash/checker.js";
+import {
+  proxyPortOf,
+  isDaemonAlive,
+  triggerProxySwitch,
+} from "../clash/proxy-switch.js";
+import { discoverAll } from "../clash/discover.js";
 
 // ---- 工具函数 ----
 
@@ -298,7 +307,8 @@ async function restartScraper(reason) {
 // ---- CDN 限流自愈（限流窗口计数 + 5 分钟结算 + 切节点 + 躺平）----
 // 模型（用户定稿）：只数"限流窗口"，成功请求完全不参与计数。
 // 每次限流（403/429）→ 计一个限流窗口 + 进入 100s 冷却（静默，请求直接 503）；
-// 5 分钟窗口内累计 2 个限流窗口 → 立即切换 Clash 节点；
+// 5 分钟窗口内累计 2 个限流窗口 → 请求切节点（汇聚到 clash-daemon：文件 IPC 强切
+// 指令，候选集/白名单/同订阅互斥由 daemon 统一裁决；daemon 未运行时回退直连切换）；
 // 窗口到期（距第一个限流窗口超过 5 分钟）时结算：限流窗口 ≥2 → 切换并重新计数；<2 → 重新计数。
 // 切节点成功 → 重新计数；连切 CDN_MAX_SWITCHES 个节点仍限流 → 躺平（持续 503 靠 nginx failover）。
 let cdnCooling = false; // 当前是否处于冷却静默期
@@ -313,6 +323,7 @@ const CDN_SWITCH_COOLDOWN_COUNT = 2; // 5 分钟窗口内限流窗口数阈值
 const CDN_SWITCH_WINDOW_MS = 5 * 60 * 1000; // 统计窗口：5 分钟
 const CDN_MAX_SWITCHES = 3; // 连续切换节点次数上限，超过躺平
 const CLASH_GROUP_NAME = "GLOBAL"; // Clash 选择器组名（与 clash/checker.js CONFIG 一致）
+let cdnSwitchChannelPort = 0; // 切节点 IPC 通道 = webserver 代理端口（0=默认通道）；startWebserver 注入
 
 /**
  * 5 分钟窗口结算（纯函数，便于单测）：
@@ -360,34 +371,78 @@ function shouldFailFast() {
 }
 
 /**
- * webserver 自己发起的节点 fallback：切换 Clash 组到第一个 delay 探测通过的候选节点。
- * 由 CDN 自愈状态机在"5 分钟内累计 2 个完整限流窗口"后调用，不依赖看门狗/daemon。
+ * 直连切换 Clash 组到第一个 delay 探测通过的候选节点。
+ * 回退路径：仅 daemon 未运行时使用（正常路径 switchNodeViaDaemon 汇聚到 daemon）。
  */
 export async function switchClashNode(reason) {
   const current = await getCurrentNode(CLASH_GROUP_NAME).catch(() => "?");
   const nodes = await listGroupNodes(CLASH_GROUP_NAME);
-  const candidates = nodes.filter((n) => n !== current);
+  // 过滤机场信息节点（剩余流量/套餐到期等，非真实出口）
+  const candidates = nodes.filter(
+    (n) => n !== current && isUsableProxyNode(n),
+  );
   if (!candidates.length) {
     throw new Error(
       `切节点失败：组 ${CLASH_GROUP_NAME} 无候选节点 (当前 ${current})`,
     );
   }
+  const probeUrl = "https://www.tiktok.com";
+  // 批量测速优先（/group/{G}/delay 含 provider 节点）：provider 模式下订阅节点
+  // 不在 /proxies 表内，逐个 /proxies/{name}/delay 必 404 → 全部误判 -1 秒失败
+  // （2026-09-28 生产实锤：44 个候选全 -1 → 误躺平）；批量不可用再回退逐个探测
+  let delayMap = await getGroupDelay(CLASH_GROUP_NAME, probeUrl, 5000);
+  if (
+    !delayMap ||
+    (Object.keys(delayMap).length > 0 &&
+      !candidates.some((c) => typeof delayMap[c] === "number"))
+  ) {
+    // 批量端点不可用或响应形状不符（不覆盖任何候选，可能是旧内核/中间层）→ 回退
+    console.error(
+      "[webserver] 批量测速不可用，回退逐个探测（provider 节点将不可见）",
+    );
+    delayMap = {};
+    for (const cand of candidates) {
+      delayMap[cand] = (await getProxyDelay(cand, probeUrl, 5000)).delay;
+    }
+  }
   for (const cand of candidates) {
-    const d = await getProxyDelay(cand, "https://www.tiktok.com", 5000);
-    if (d.delay > 0 && !d.timeout) {
+    const delay = delayMap[cand];
+    if (typeof delay === "number" && delay > 0) {
       await switchProxy(CLASH_GROUP_NAME, cand);
       console.error(
-        `[webserver] 已切换 Clash 节点: ${current} → ${cand} (delay=${d.delay}ms) [${reason}]`,
+        `[webserver] 已切换 Clash 节点: ${current} → ${cand} (delay=${delay}ms) [${reason}]`,
       );
       return cand;
     }
     console.error(
-      `[webserver] 候选节点探测不通，跳过: ${cand} (delay=${d.delay}ms)`,
+      `[webserver] 候选节点探测不通，跳过: ${cand} (delay=${delay ?? -1}ms)`,
     );
   }
   throw new Error(`切节点失败：${candidates.length} 个候选均探测不通`);
 }
 
+/**
+ * 通过 daemon 切换节点（首选路径）：文件 IPC 发 failover 强切指令（force=true——
+ * webserver 自身已完成节流：100s 冷却 + 5min 2 窗口 + 3 次上限，触发时必须真切），
+ * 等待 daemon（10s 轮询 + 探测/候选验证）完成后核对 GLOBAL 当前节点。
+ * 节点选择/白名单守卫/同订阅互斥全部由 daemon 统一裁决，webserver 不直接操作控制器。
+ * @returns {Promise<string|undefined|null>}
+ *   新节点名；undefined = daemon 未运行（调用方回退直连）；null = 命令已发但节点未变化
+ */
+async function switchNodeViaDaemon(reason) {
+  if (!isDaemonAlive(cdnSwitchChannelPort)) return undefined;
+  const before = await getCurrentNode(CLASH_GROUP_NAME).catch(() => "?");
+  console.error(
+    `[webserver] 节点切换汇聚到 daemon (通道 ${cdnSwitchChannelPort || "默认"}，当前 ${before}) [${reason}]`,
+  );
+  // daemon 10s 轮询命令 + 逐候选内容验证，给足等待
+  await triggerProxySwitch(reason, cdnSwitchChannelPort, 45_000, {
+    force: true,
+  });
+  const after = await getCurrentNode(CLASH_GROUP_NAME).catch(() => "?");
+  return after && after !== before ? after : null;
+}
+
 // 触发切换 Clash 节点（防重入；连切上限；成功重置计数）
 function startCdnSwitch() {
   if (cdnSwitching || cdnGiveUp) return;
@@ -403,9 +458,20 @@ function startCdnSwitch() {
   );
   cdnSwitching = true;
   cdnSwitchCount++;
-  switchClashNode(
-    `5 分钟内累计 ${cdnCooldownCount} 个完整限流窗口，触发第 ${cdnSwitchCount} 次切节点`,
-  )
+  const switchReason = `5 分钟内累计 ${cdnCooldownCount} 个完整限流窗口，触发第 ${cdnSwitchCount} 次切节点`;
+  switchNodeViaDaemon(switchReason)
+    .then(async (node) => {
+      if (node === undefined) {
+        console.error("[webserver] daemon 未运行，回退直连切换 Clash 节点");
+        return switchClashNode(switchReason);
+      }
+      if (node === null) {
+        throw new Error(
+          "daemon 已收到切换命令但节点未变化（候选集为空或候选均验证失败）",
+        );
+      }
+      return node;
+    })
     .then((node) => {
       // 切换成功：重新计数（窗口起点与限流窗口数都清零），新节点重新累计
       cdnCooldownCount = 0;
@@ -848,6 +914,29 @@ export async function startWebserver(
   if (proxyServer) {
     SCRAPER_CONFIG.proxyServer = proxyServer;
   }
+  // 节点切换通道与控制器对齐（多实例各归各：代理 7897→控制器 9097，7898→9098）。
+  // 不对齐的话，第二个 webserver 实例的直连切换会打到默认 9097，切错控制器。
+  cdnSwitchChannelPort = proxyPortOf(SCRAPER_CONFIG.proxyServer);
+  try {
+    const controllers = await discoverAll();
+    const mine =
+      controllers.find((c) => c.proxyPort === cdnSwitchChannelPort) ||
+      (cdnSwitchChannelPort === 0 ? controllers[0] : null);
+    if (mine) {
+      configureClashApi({ port: mine.port, secret: mine.secret });
+      console.error(
+        `[webserver] Clash 控制器对齐: 代理 ${cdnSwitchChannelPort || "默认"} → api ${mine.port} (${mine.source})`,
+      );
+    } else {
+      console.error(
+        `[webserver] 未发现代理 ${cdnSwitchChannelPort} 对应的控制器，节点切换沿用默认端口`,
+      );
+    }
+  } catch (e) {
+    console.error(
+      `[webserver] Clash 控制器发现失败，节点切换沿用默认端口: ${e.message}`,
+    );
+  }
   if (captchaNotifyUrl) {
     SCRAPER_CONFIG.captchaNotifyUrl = captchaNotifyUrl;
   }