tt-help-cli-ycl 1.4.154 → 1.4.155

package/package.json

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

package/scripts/test-daemon-whitelist.mjs

@@ -0,0 +1,308 @@
+/**
+ * daemon 白名单守卫 _enforceWhitelist 单测（2026-09-21，无需 Clash 运行）
+ *
+ * 验证：
+ *   - whitelistGuard 默认开启，显式 false 才关闭
+ *   - 守卫关闭 / node 空(?) / 候选集空 / 节点在列表内 / dry-run → 放行不切
+ *   - 越界节点 → 按候选排序逐个切换+内容验证，第一个满足即切回
+ *   - 首个候选验证失败 → 落到下一候选
+ *   - 候选全部不可用 → 恢复原节点（与 failover 口径一致，返回 false）
+ *   - 切回成功 → 返回 true + 优雅断连 + 更新切换锚点 + health 写入 lastSwitch
+ *   - setWhitelistGuard IPC 命令动态开关（boolean/"false" 字符串/缺省）
+ *   - 集成：壳页分支 / 复测恢复分支同样触发守卫（列表外节点不允许）
+ *
+ * 运行: node --experimental-test-module-mocks --test scripts/test-daemon-whitelist.mjs
+ */
+import { test, mock, before } from "node:test";
+import assert from "node:assert/strict";
+
+// ── 可配置假依赖状态 ──
+const state = {
+  // 巡检探针结果（healthy 分支用）；healthSeq 非空时按序消费（复测恢复场景）
+  health: {
+    healthy: true,
+    httpCode: 200,
+    timeTotal: 1.2,
+    sizeDownload: 100000,
+    numRedirects: 0,
+    title: "TikTok - Make Your Day",
+    error: null,
+  },
+  healthSeq: null,
+  // 候选集（咱们节点列表）
+  nodes: ["🇺🇸 美国01", "🇬🇧 英国02"],
+  // 当前正在使用的节点（默认 = 列表外越界节点）
+  currentNode: "列表外节点X",
+  switches: [],
+  healthWrites: [],
+  idleCloses: 0,
+  // 切到这些节点后内容验证失败（模拟候选也不可用）
+  failSwitchTargets: null,
+  proxyMap: {},
+};
+
+function resetState() {
+  state.health = {
+    healthy: true,
+    httpCode: 200,
+    timeTotal: 1.2,
+    sizeDownload: 100000,
+    numRedirects: 0,
+    title: "TikTok - Make Your Day",
+    error: null,
+  };
+  state.healthSeq = null;
+  state.nodes = ["🇺🇸 美国01", "🇬🇧 英国02"];
+  state.currentNode = "列表外节点X";
+  state.switches = [];
+  state.healthWrites = [];
+  state.idleCloses = 0;
+  state.failSwitchTargets = null;
+  state.proxyMap = {};
+}
+
+/** 巡检探针：healthSeq 优先，否则固定 state.health */
+function probeHealth() {
+  if (state.healthSeq && state.healthSeq.length) {
+    return { ...state.healthSeq.shift() };
+  }
+  return { ...state.health };
+}
+
+// ── 注册模块 mock（必须在 import daemon.js 之前） ──
+before(async () => {
+  mock.module("../src/clash/checker.js", {
+    namedExports: {
+      normalizeCountries: (v) => (Array.isArray(v) ? [...v] : v ? [v] : []),
+      CONFIG: {
+        groupName: "GLOBAL",
+        testUrl: "https://www.tiktok.com/@tiktok",
+        proxyUrl: "http://127.0.0.1:7897",
+        nodeCountryFilter: null,
+      },
+      checkNodeHealth: () => probeHealth(),
+      loadHealthyList: () => ({ nodes: [...state.nodes] }),
+      switchToNode: async (n) => {
+        state.switches.push(n);
+        state.currentNode = n;
+        if (state.failSwitchTargets && state.failSwitchTargets.has(n)) {
+          // 切过去了但内容验证失败（非壳页异常）
+          state.health = {
+            ...state.health,
+            healthy: false,
+            error: "timeout",
+            numRedirects: 0,
+            title: "",
+          };
+          return true;
+        }
+        state.health = { ...state.health, healthy: true, error: null };
+        return true;
+      },
+      applyDiscovered: () => {},
+      checkClashAlive: () => true,
+      pruneHealthyListByCurrentProxies: () => ({
+        kept: state.nodes.length,
+        removed: 0,
+        allGone: false,
+      }),
+      runDelayProbe: async () => ({
+        nodes: [...state.nodes],
+        total: state.nodes.length,
+      }),
+      saveHealthyList: () => {},
+    },
+  });
+  mock.module("../src/clash/api.js", {
+    namedExports: {
+      configure: () => {},
+      getProxies: async () => ({ proxies: { ...state.proxyMap } }),
+      getCurrentNode: async () => state.currentNode,
+      closeAllConnections: async () => {},
+      closeIdleConnections: async () => {
+        state.idleCloses += 1;
+        return { closed: 3, active: 0 };
+      },
+    },
+  });
+  mock.module("../src/clash/ipc.js", {
+    namedExports: {
+      writeHealth: (...args) => {
+        const data = args.find(
+          (a) => a && typeof a === "object" && "node" in a,
+        );
+        if (data) state.healthWrites.push(data);
+      },
+      listCommandChannels: () => [],
+      readCommand: () => null,
+      clearCommand: () => {},
+    },
+  });
+  mock.module("../src/clash/discover.js", {
+    namedExports: {
+      discoverAll: async () => [],
+      invalidateDiscoverCache: () => {},
+    },
+  });
+  ({ ClashDaemon } = await import("../src/clash/daemon.js"));
+});
+
+let ClashDaemon = null;
+
+function makeCtx(opts = {}) {
+  const d = new ClashDaemon(opts);
+  const c = { proxyPort: 7897 };
+  return { d, c };
+}
+
+/** 取最后一次 health 写入 */
+function lastWrite() {
+  return state.healthWrites[state.healthWrites.length - 1] || null;
+}
+
+test("W1 whitelistGuard 默认开启，显式 false 才关闭", () => {
+  assert.equal(new ClashDaemon({}).whitelistGuard, true);
+  assert.equal(
+    new ClashDaemon({ whitelistGuard: false }).whitelistGuard,
+    false,
+  );
+});
+
+test("W2 守卫关闭：越界也放行，不切换", async () => {
+  resetState();
+  const { d, c } = makeCtx({ whitelistGuard: false });
+  assert.equal(await d._enforceWhitelist(c, state.currentNode), false);
+  assert.equal(state.switches.length, 0, "守卫关闭不应切换");
+});
+
+test("W3 node 为空或 '?'（API 失败）：放行防误切", async () => {
+  resetState();
+  const { d, c } = makeCtx();
+  assert.equal(await d._enforceWhitelist(c, ""), false);
+  assert.equal(await d._enforceWhitelist(c, "?"), false);
+  assert.equal(state.switches.length, 0);
+});
+
+test("W4 候选集为空：放行（由 delay 初测补齐）", async () => {
+  resetState();
+  state.nodes = [];
+  const { d, c } = makeCtx();
+  assert.equal(await d._enforceWhitelist(c, state.currentNode), false);
+  assert.equal(state.switches.length, 0);
+});
+
+test("W5 当前节点在列表内：放行", async () => {
+  resetState();
+  state.currentNode = "🇺🇸 美国01";
+  const { d, c } = makeCtx();
+  assert.equal(await d._enforceWhitelist(c, state.currentNode), false);
+  assert.equal(state.switches.length, 0);
+});
+
+test("W6 dry-run：越界只记录不切换", async () => {
+  resetState();
+  const { d, c } = makeCtx({ dryRun: true });
+  assert.equal(await d._enforceWhitelist(c, state.currentNode), false);
+  assert.equal(state.switches.length, 0, "dry-run 不应实际切换");
+});
+
+test("W7 越界正常切回：返回 true + 断连 + 锚点 + health 记录", async () => {
+  resetState();
+  const { d, c } = makeCtx();
+  const r = await d._enforceWhitelist(c, state.currentNode);
+  assert.equal(r, true, "切回成功应返回 true");
+  assert.deepEqual(state.switches, ["🇺🇸 美国01"], "未切过候选按原序优先");
+  assert.equal(state.idleCloses, 1, "切回后应优雅断连");
+  assert.ok(
+    c._lastSwitchAt && c._lastSwitchAt > Date.now() - 5000,
+    "切回后应更新切换锚点",
+  );
+  const w = lastWrite();
+  assert.ok(w, "应写入 health");
+  assert.equal(w.node, "🇺🇸 美国01");
+  assert.match(w.lastSwitch, /白名单守卫/);
+});
+
+test("W8 首候选验证失败：落到下一候选", async () => {
+  resetState();
+  state.failSwitchTargets = new Set(["🇺🇸 美国01"]);
+  const { d, c } = makeCtx();
+  const r = await d._enforceWhitelist(c, state.currentNode);
+  assert.equal(r, true);
+  assert.deepEqual(
+    state.switches,
+    ["🇺🇸 美国01", "🇬🇧 英国02"],
+    "首候选失败应尝试下一候选",
+  );
+  assert.equal(lastWrite().node, "🇬🇧 英国02");
+});
+
+test("W9 候选全部不可用：恢复原节点，返回 false（与 failover 口径一致）", async () => {
+  resetState();
+  state.failSwitchTargets = new Set(["🇺🇸 美国01", "🇬🇧 英国02"]);
+  const { d, c } = makeCtx();
+  const r = await d._enforceWhitelist(c, state.currentNode);
+  assert.equal(r, false, "全部候选失败应返回 false");
+  assert.deepEqual(
+    state.switches,
+    ["🇺🇸 美国01", "🇬🇧 英国02", "列表外节点X"],
+    "试完全部候选后应恢复原节点（试切过程会真的切换 API）",
+  );
+  assert.equal(state.currentNode, "列表外节点X", "应恢复原节点");
+  const w = lastWrite();
+  assert.ok(w, "恢复后应写 health 便于监控页可见");
+  assert.equal(w.node, "列表外节点X");
+  assert.match(w.error, /候选全部不可用/);
+});
+
+test("W10 setWhitelistGuard IPC 命令动态开关", () => {
+  resetState();
+  const { d } = makeCtx();
+  d._cmdHandlers.setWhitelistGuard({ enabled: true });
+  assert.equal(d.whitelistGuard, true);
+  d._cmdHandlers.setWhitelistGuard({ enabled: false });
+  assert.equal(d.whitelistGuard, false);
+  d._cmdHandlers.setWhitelistGuard({ enabled: "false" });
+  assert.equal(d.whitelistGuard, false, "字符串 'false' 应解析为关闭");
+  d._cmdHandlers.setWhitelistGuard({});
+  assert.equal(d.whitelistGuard, true, "缺省 enabled 应解析为开启");
+});
+
+test("W11 集成：壳页分支同样触发守卫（列表外不允许）", async () => {
+  resetState();
+  // 壳页签名：200 + 无跳转 + 无 error + 无 title
+  state.health = {
+    healthy: false,
+    httpCode: 200,
+    timeTotal: 1.0,
+    sizeDownload: 43000,
+    numRedirects: 0,
+    title: "",
+    error: null,
+  };
+  const { d, c } = makeCtx();
+  await d._healthCheckController(c);
+  assert.deepEqual(
+    state.switches,
+    ["🇺🇸 美国01"],
+    "壳页=链路正常，但越界节点仍应被守卫切回",
+  );
+  assert.equal(lastWrite().node, "🇺🇸 美国01", "最终 health 应为守卫切回结果");
+});
+
+test("W12 集成：复测恢复分支同样触发守卫（列表外不允许）", async () => {
+  resetState();
+  // 首次异常 → 复测恢复（列表外节点仍不允许）
+  state.healthSeq = [
+    { healthy: false, httpCode: 0, timeTotal: 0, sizeDownload: 0, numRedirects: 0, title: "", error: "timeout" },
+    { ...state.health },
+  ];
+  const { d, c } = makeCtx();
+  await d._healthCheckController(c); // 内部含 3s 复测等待
+  assert.deepEqual(
+    state.switches,
+    ["🇺🇸 美国01"],
+    "复测恢复后越界节点应被守卫切回",
+  );
+  assert.equal(lastWrite().node, "🇺🇸 美国01");
+});

package/scripts/test-explore-captcha-wait.mjs

@@ -0,0 +1,170 @@
+// 验证：explore 两条验证码路径的轮询等待与计数语义
+// 1) waitForCaptchaResolved：解决即继续（提前返回）/ 超时关不掉返回 false / 超时关闭成功返回 true
+// 2) 计数语义：解决后 captchaCount--（同一验证码不再重复计数凑阈值）
+// 运行：node scripts/test-explore-captcha-wait.mjs
+let pass = 0;
+let fail = 0;
+function check(name, ok, detail = "") {
+  if (ok) {
+    pass++;
+    console.log(`✓ ${name}${detail ? `: ${detail}` : ""}`);
+  } else {
+    fail++;
+    console.error(`✗ ${name}${detail ? `: ${detail}` : ""}`);
+  }
+}
+
+// 从 explore.js 提取 waitForCaptchaResolved 函数源码做行为验证（依赖注入 page + captchaWaitMin）
+const fs = await import("node:fs");
+const src = fs.readFileSync("src/cli/explore.js", "utf8");
+const start = src.indexOf("async function waitForCaptchaResolved()");
+if (start < 0) throw new Error("waitForCaptchaResolved not found");
+let depth = 0;
+let end = -1;
+for (let i = src.indexOf("{", start); i < src.length; i++) {
+  if (src[i] === "{") depth++;
+  else if (src[i] === "}") {
+    depth--;
+    if (depth === 0) {
+      end = i + 1;
+      break;
+    }
+  }
+}
+const fnSrc = src.slice(start, end);
+
+// 缩短轮询间隔：把 15000ms 替换为 30ms（仅测试，语义不变）
+const fnSrcFast = fnSrc
+  .replace(/setTimeout\(r, 15000\)/g, "setTimeout(r, 30)")
+  .replace(/setTimeout\(r, 2000\)/g, "setTimeout(r, 30)");
+
+function makeHarness({ captchaStillVisible, detectThrows = false }) {
+  // captchaStillVisible: () => bool，控制验证码是否还可见
+  const page = {
+    evaluate: async (fn) => {
+      if (detectThrows) throw new Error("Execution context was destroyed");
+      if (fn.toString().includes("captcha-verify-container")) {
+        return captchaStillVisible() ? { exists: true, visible: true } : null;
+      }
+      return null;
+    },
+  };
+  return { page };
+}
+
+// 用例1：验证码在等待期间被解决 → 提前返回 true（不再等满 3 分钟）
+{
+  let visible = true;
+  setTimeout(() => (visible = false), 100); // 100ms 后人工解决
+  const { page } = makeHarness({ captchaStillVisible: () => visible });
+  const t0 = Date.now();
+  const result = await new Promise((resolve) => {
+    const module = new Function(
+      "page",
+      "captchaWaitMin",
+      "detectCaptcha",
+      "closeCaptcha",
+      `return (async () => { ${fnSrcFast}
+        return await waitForCaptchaResolved();
+      })()`,
+    );
+    const dc = async () => (visible ? { exists: true, visible: true } : null);
+    resolve(module(page, 3, dc, async () => {}));
+  });
+  const elapsed = Date.now() - t0;
+  check(
+    "等待期间解决 → 提前返回 true",
+    result === true && elapsed < 3000,
+    `elapsed=${elapsed}ms`,
+  );
+}
+
+// 用例2：验证码一直不解决 → 超时后关闭失败 → false（计数切账户由调用方处理）
+{
+  const captchaStillVisible0 = () => true; // 永远可见
+  const { page } = makeHarness({ captchaStillVisible: captchaStillVisible0 });
+  const captchaWaitMin = 0.001; // 60ms（以分钟计）
+  const result = await new Promise((resolve) => {
+    const module = new Function(
+      "page",
+      "captchaWaitMin",
+      "detectCaptcha",
+      "closeCaptcha",
+      `return (async () => { ${fnSrcFast}
+        return await waitForCaptchaResolved();
+      })()`,
+    );
+    const dc = async () => ({ exists: true, visible: true });
+    resolve(module(page, captchaWaitMin, dc, async () => {}));
+  });
+  check("一直未解决+关闭失败 → false", result === false);
+}
+
+// 用例3：超时后 closeCaptcha 关掉了 → true
+{
+  let visible = true;
+  const { page } = makeHarness({ captchaStillVisible: () => visible });
+  const captchaWaitMin = 0.001;
+  let closeCalled = false;
+  const result = await new Promise((resolve) => {
+    const module = new Function(
+      "page",
+      "captchaWaitMin",
+      "detectCaptcha",
+      "closeCaptcha",
+      `return (async () => { ${fnSrcFast}
+        return await waitForCaptchaResolved();
+      })()`,
+    );
+    const dc = async () => (visible ? { exists: true, visible: true } : null);
+    const cc = async () => {
+      closeCalled = true;
+      visible = false; // 关闭成功
+    };
+    resolve(module(page, captchaWaitMin, dc, cc));
+  });
+  check(
+    "超时后关闭成功 → true（尝试过 closeCaptcha）",
+    result === true && closeCalled === true,
+  );
+}
+
+// 用例4：detectCaptcha 抛异常（页面重建中）→ 按已解决处理返回 true，不卡死
+{
+  const { page } = makeHarness({
+    captchaStillVisible: () => true,
+    detectThrows: true,
+  });
+  const result = await new Promise((resolve) => {
+    const module = new Function(
+      "page",
+      "captchaWaitMin",
+      "detectCaptcha",
+      "closeCaptcha",
+      `return (async () => { ${fnSrcFast}
+        return await waitForCaptchaResolved();
+      })()`,
+    );
+    const dc = async () => {
+      throw new Error("Execution context was destroyed");
+    };
+    resolve(module(page, 3, dc, async () => {}));
+  });
+  check("检测异常 → 按已解决返回 true（不卡死）", result === true);
+}
+
+// 用例5：计数语义（代码结构断言）——两条路径均含 resolved 后 captchaCount--
+{
+  const hasPath1 =
+    src.includes("captchaCount--; // 解决了就不算一次独立事件") ||
+    src.includes("captchaCount--; // 解决了就不算");
+  const hasPath2 = src.includes("captchaCount--; // 人工解决了，不算独立事件");
+  check(
+    "两条路径都有解决后回退计数",
+    hasPath1 && hasPath2,
+    `path1=${hasPath1} path2=${hasPath2}`,
+  );
+}
+
+console.error(`\n结果: ${pass} 通过, ${fail} 失败`);
+process.exit(fail > 0 ? 1 : 0);