tt-help-cli-ycl 1.4.153 → 1.4.155

package/package.json

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

package/scripts/test-api-interceptor-captcha.mjs

@@ -16,8 +16,13 @@ function check(name, ok, detail = "") {
 }
 
 // 429 + 页面有验证码容器
-function make429CaptchaPage(username) {
+// captchaPhase 控制验证码何时出现：
+//   "instant"  → 首次检测时已渲染（进分支 5s 检测命中）
+//   "delayed"  → 首次检测时未渲染，进入重试等待后才出现（sleep 醒来后 3s 检测命中）
+//   "never"    → 不出现（走正常被封重试）
+function make429CaptchaPage(username, captchaPhase = "instant") {
   let gotoCount = 0;
+  let captchaDelayElapsed = false;
   const page = {
     _handlers: {},
     on(event, fn) {
@@ -33,12 +38,16 @@ function make429CaptchaPage(username) {
       gotoCount++;
     },
     // checkCdpHealth 用 () => document.readyState（fn.length===0）→ "complete"
-    // detectCaptcha 用 () => {...}（fn.length===0，通过 captchaVisible 开关控制返回值）
-    _captchaVisible: true,
+    // detectCaptcha/detectCaptchaWithWait 通过 captchaDelayElapsed 开关控制
+    _captchaVisible() {
+      if (captchaPhase === "never") return false;
+      if (captchaPhase === "instant") return true;
+      return captchaDelayElapsed; // delayed：等待后才可见
+    },
     evaluate: async (fn) => {
       if (
-        page._captchaVisible &&
-        fn.toString().includes("captcha-verify-container")
+        fn.toString().includes("captcha-verify-container") &&
+        page._captchaVisible()
       ) {
         return {
           exists: true,
@@ -50,8 +59,18 @@ function make429CaptchaPage(username) {
       if (fn.length === 1) return null;
       return "complete";
     },
+    waitForFunction: async (fn, opts) => {
+      // 带等待检测：轮询语义——可见即返回 handle，否则等满 timeout 返回 null
+      const deadline = Date.now() + (opts?.timeout || 5000);
+      while (Date.now() < deadline) {
+        if (page._captchaVisible()) {
+          return { jsonValue: async () => true };
+        }
+        await new Promise((r) => setTimeout(r, 5));
+      }
+      return null;
+    },
     reload: async () => {},
-    waitForFunction: async () => null,
     waitForResponse: async (pred) => {
       const resp = {
         url: () => "https://www.tiktok.com/api/post/item_list/?...",
@@ -68,34 +87,61 @@ function make429CaptchaPage(username) {
     get gotoCount() {
       return gotoCount;
     },
+    // 测试钩子：标记 delayed 验证码已出现
+    _markCaptchaDelayed() {
+      captchaDelayElapsed = true;
+    },
   };
   return page;
 }
 
-// 用例1：429 + 验证码可见 → 立即抛 "验证码:"，只 goto 1 次（无重试）
+// 用例1：429 + 验证码立即可见 → 首次检测命中，只 goto 1 次（无重试）
 {
-  const page = make429CaptchaPage("fumolbbf08o");
+  const page = make429CaptchaPage("fumolbbf08o", "instant");
   try {
     await fetchUserVideosAPI(page, "fumolbbf08o", 5, () => {});
-    check("429+验证码 立即转验证码", false, "未抛错");
+    check("429+验证码(即时) 立即转验证码", false, "未抛错");
   } catch (e) {
     check(
-      "429+验证码 立即转验证码",
+      "429+验证码(即时) 立即转验证码",
       e.message === "验证码: fumolbbf08o",
       `抛错 "${e.message}"`,
     );
   }
   check(
-    "429+验证码 不再重试（仅 1 次 goto）",
+    "429+验证码(即时) 不再重试（仅 1 次 goto）",
     page.gotoCount === 1,
     `goto 次数 = ${page.gotoCount}`,
   );
 }
 
-// 用例2：429 + 验证码不可见 → 仍走正常被封重试，最终抛 "被封:"
+// 用例2（核心场景）：429 首检时验证码未渲染 → 重试等待期间弹出
+// → sleep 醒来后的检测必须抓住它（下次 goto 冲掉前），抛 "验证码:"
+{
+  const page = make429CaptchaPage("fumolbbf08o", "delayed");
+  // 在 waitForFunction 轮询到 captchaDelayElapsed=false 一轮后标记出现，
+  // 模拟"等待期渲染"：用 setTimeout 在重试 sleep 期间触发
+  setTimeout(() => page._markCaptchaDelayed(), 50);
+  try {
+    await fetchUserVideosAPI(page, "fumolbbf08o", 5, () => {});
+    check("等待期间弹出的验证码 被醒来检测抓住", false, "未抛错");
+  } catch (e) {
+    check(
+      "等待期间弹出的验证码 被醒来检测抓住",
+      e.message === "验证码: fumolbbf08o",
+      `抛错 "${e.message}"，goto ${page.gotoCount} 次`,
+    );
+  }
+  check(
+    "醒来检测抓住时未再发起下一轮 goto（goto ≤ 2）",
+    page.gotoCount <= 2,
+    `goto 次数 = ${page.gotoCount}`,
+  );
+}
+
+// 用例3：429 + 验证码始终不出现 → 走正常被封重试，最终抛 "被封:"
 {
-  const page = make429CaptchaPage("fumolbbf08o");
-  page._captchaVisible = false;
+  const page = make429CaptchaPage("fumolbbf08o", "never");
   try {
     await fetchUserVideosAPI(page, "fumolbbf08o", 5, () => {});
     check("429无验证码 仍按被封重试", false, "未抛错");
@@ -108,15 +154,11 @@ function make429CaptchaPage(username) {
   }
 }
 
-// 用例3：429 + detectCaptcha 本身抛异常（页面上下文销毁）→ 忽略，按被封重试
+// 用例4：429 + waitForFunction/检测本身抛异常（上下文销毁）→ 忽略，按被封重试
 {
-  const page = make429CaptchaPage("fumolbbf08o");
-  page.evaluate = async (fn) => {
-    if (fn.toString().includes("captcha-verify-container")) {
-      throw new Error("Execution context was destroyed");
-    }
-    if (fn.length === 1) return null;
-    return "complete";
+  const page = make429CaptchaPage("fumolbbf08o", "never");
+  page.waitForFunction = async () => {
+    throw new Error("Execution context was destroyed");
   };
   try {
     await fetchUserVideosAPI(page, "fumolbbf08o", 5, () => {});

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);