tt-help-cli-ycl 1.4.126 → 1.4.130

package/package.json

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

package/scripts/test-daemon-failover.mjs

@@ -0,0 +1,197 @@
+/**
+ * daemon _handleFailover 三级响应单测（2026-08-22，无需 Clash 运行）
+ *
+ * 验证：
+ *   - 探针健康 → 窗口内 failover 仅检查不切换（前 N-1 次）
+ *   - 探针不健康 → 立即切换（无视窗口）
+ *   - 壳页 → 视为链路正常，仅检查不切换（与巡检口径一致）
+ *   - 窗口过期 → 计数重置
+ *   - 窗口内到达 failoverEscapeAfter 次 → 按业务级封禁轮换一次
+ *   - 实际切换后 → 窗口与计数重置
+ *   - escapeAfter 可配置
+ *   - 候选集为空 → 触发 delay 初测且不切换
+ *
+ * 运行: node --test scripts/test-daemon-failover.mjs
+ *      （若当前 Node 版本 module mock 仍需 flag: --experimental-test-module-mocks）
+ */
+import { test, mock, before } from "node:test";
+import assert from "node:assert/strict";
+
+// ── 可配置假依赖状态 ──
+const state = {
+  health: {
+    healthy: true,
+    httpCode: 200,
+    timeTotal: 1.2,
+    sizeDownload: 100000,
+    numRedirects: 0,
+    title: "TikTok - Make Your Day",
+    error: null,
+  },
+  nodes: ["🇭🇰 香港01", "🇲🇾 马来02"],
+  currentNode: "🇭🇰 香港01",
+  switches: [],
+  closes: 0,
+};
+
+function resetState() {
+  state.health = {
+    healthy: true,
+    httpCode: 200,
+    timeTotal: 1.2,
+    sizeDownload: 100000,
+    numRedirects: 0,
+    title: "TikTok - Make Your Day",
+    error: null,
+  };
+  state.nodes = ["🇭🇰 香港01", "🇲🇾 马来02"];
+  state.currentNode = "🇭🇰 香港01";
+  state.switches = [];
+  state.closes = 0;
+}
+
+// ── 注册模块 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/explore",
+        proxyUrl: "http://127.0.0.1:7897",
+        nodeCountryFilter: null,
+      },
+      checkNodeHealth: () => ({ ...state.health }),
+      loadHealthyList: () => ({ nodes: [...state.nodes] }),
+      switchToNode: async (n) => {
+        state.switches.push(n);
+        state.currentNode = n;
+        // 模拟真实世界：故障属于原节点，切换后的新节点健康（候选内容验证通过）
+        state.health = { ...state.health, healthy: true, error: null };
+        return true;
+      },
+      applyDiscovered: () => {},
+      runDelayProbe: async () => ({
+        nodes: [...state.nodes],
+        total: state.nodes.length,
+      }),
+      saveHealthyList: () => {},
+    },
+  });
+  mock.module("../src/clash/api.js", {
+    namedExports: {
+      configure: () => {},
+      getCurrentNode: async () => state.currentNode,
+      closeAllConnections: async () => {
+        state.closes += 1;
+      },
+    },
+  });
+  mock.module("../src/clash/ipc.js", {
+    namedExports: {
+      writeHealth: () => {},
+      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({
+    failoverCooldownMs: 600000,
+    failoverEscapeAfter: 3,
+    ...opts,
+  });
+  const c = { proxyPort: 7897 };
+  return { d, c };
+}
+
+test("F1 探针健康：前 2 次 failover 仅检查不切换，第 3 次轮换", async () => {
+  resetState();
+  const { d, c } = makeCtx();
+  await d._handleFailover({ reason: "F1-1" }, c);
+  await d._handleFailover({ reason: "F1-2" }, c);
+  assert.equal(state.switches.length, 0, "前 2 次不应切换");
+  assert.equal(state.closes, 0, "前 2 次不应断开连接");
+  await d._handleFailover({ reason: "F1-3" }, c);
+  assert.deepEqual(state.switches, ["🇲🇾 马来02"], "第 3 次按轮换切换到候选");
+  assert.equal(state.closes, 1, "切换后应断开旧连接");
+});
+
+test("F2 探针不健康：立即切换（无视窗口）", async () => {
+  resetState();
+  const { d, c } = makeCtx();
+  state.health = { ...state.health, healthy: false, error: "timeout" };
+  await d._handleFailover({ reason: "F2" }, c);
+  assert.deepEqual(state.switches, ["🇲🇾 马来02"], "不健康应立即切换");
+});
+
+test("F3 壳页视为链路正常：仅检查不切换", async () => {
+  resetState();
+  const { d, c } = makeCtx();
+  // 壳页签名：200 + 无跳转 + 无 error + 无 title
+  state.health = {
+    healthy: false,
+    httpCode: 200,
+    timeTotal: 1.0,
+    sizeDownload: 43000,
+    numRedirects: 0,
+    title: "",
+    error: null,
+  };
+  await d._handleFailover({ reason: "F3" }, c);
+  assert.equal(state.switches.length, 0, "壳页不应触发切换");
+});
+
+test("F4 窗口过期：计数重置，不累计到逃生阈值", async () => {
+  resetState();
+  const { d, c } = makeCtx({ failoverCooldownMs: 150 });
+  await d._handleFailover({ reason: "F4-1" }, c); // count=1
+  await new Promise((r) => setTimeout(r, 200)); // 窗口过期
+  await d._handleFailover({ reason: "F4-2" }, c); // 重置后 count=1
+  await d._handleFailover({ reason: "F4-3" }, c); // count=2
+  assert.equal(state.switches.length, 0, "窗口过期后不应累计旧计数");
+  await d._handleFailover({ reason: "F4-4" }, c); // count=3 → 轮换
+  assert.equal(state.switches.length, 1, "第 3 次才应轮换");
+});
+
+test("F5 切换后窗口重置：重新从仅检查开始", async () => {
+  resetState();
+  const { d, c } = makeCtx();
+  await d._handleFailover({ reason: "F5-1" }, c); // skip
+  await d._handleFailover({ reason: "F5-2" }, c); // skip
+  await d._handleFailover({ reason: "F5-3" }, c); // switch
+  assert.equal(state.switches.length, 1, "第 3 次应切换");
+  await d._handleFailover({ reason: "F5-4" }, c); // 重置后 count=1 → skip
+  assert.equal(state.switches.length, 1, "切换后应重置窗口，不连续切换");
+  await d._handleFailover({ reason: "F5-5" }, c); // count=2 → skip
+  await d._handleFailover({ reason: "F5-6" }, c); // count=3 → switch
+  assert.equal(state.switches.length, 2, "第 6 次才应再次轮换");
+});
+
+test("F6 escapeAfter 可配置：=1 时首次健康 failover 即轮换", async () => {
+  resetState();
+  const { d, c } = makeCtx({ failoverEscapeAfter: 1 });
+  await d._handleFailover({ reason: "F6" }, c);
+  assert.equal(state.switches.length, 1, "escapeAfter=1 应首次即切换");
+});
+
+test("F7 候选集为空：触发 delay 初测且不切换", async () => {
+  resetState();
+  const { d, c } = makeCtx();
+  state.health = { ...state.health, healthy: false, error: "timeout" };
+  state.nodes = [];
+  await d._handleFailover({ reason: "F7" }, c);
+  assert.equal(state.switches.length, 0, "无候选不应切换");
+  assert.ok(c._lastProbeAt, "应触发过 delay 初测");
+});

package/scripts/test-daemon-switch-history.mjs

@@ -0,0 +1,141 @@
+/**
+ * daemon 切换历史排序单测（无需 Clash 运行）
+ * 验证 _sortCandidates / _markSwitch 的纯时间轮换（后进后出）行为
+ */
+import { ClashDaemon } from "../src/clash/daemon.js";
+
+let pass = 0;
+let fail = 0;
+function ok(cond, name, detail = "") {
+  if (cond) {
+    pass++;
+    console.log(`  ✓ ${name}`);
+  } else {
+    fail++;
+    console.error(`  ✗ ${name} ${detail}`);
+  }
+}
+
+const d = new ClashDaemon({});
+const nodes = ["A", "B", "C", "D"];
+const T0 = Date.now();
+
+// T1 无历史 → 原序
+{
+  const c = { proxyPort: 1 };
+  ok(
+    JSON.stringify(d._sortCandidates(nodes, c)) === JSON.stringify(nodes),
+    "T1 无历史保持原序",
+  );
+}
+
+// T2 切过沉底，未切过保持原序
+{
+  const c = { proxyPort: 2 };
+  c._switchHistory = new Map([["B", T0 - 10_000]]);
+  const r = d._sortCandidates(nodes, c);
+  ok(r.join() === "A,C,D,B", "T2 切过沉底，未切过保持原序", r.join());
+}
+
+// T3 切过按切换时间升序，未切过最前
+{
+  const c = { proxyPort: 3 };
+  c._switchHistory = new Map([
+    ["C", T0 - 2_000],
+    ["A", T0 - 1_000],
+  ]);
+  const r = d._sortCandidates(nodes, c);
+  ok(r.join() === "B,D,C,A", "T3 切过按切换时间升序，未切过最前", r.join());
+}
+
+// T4 全部切过 → 完全按切换时间轮换
+{
+  const c = { proxyPort: 4 };
+  c._switchHistory = new Map([
+    ["A", T0 - 4_000],
+    ["B", T0 - 1_000],
+    ["C", T0 - 3_000],
+    ["D", T0 - 2_000],
+  ]);
+  const r = d._sortCandidates(nodes, c);
+  ok(r.join() === "A,C,D,B", "T4 全切过按切换时间轮换", r.join());
+}
+
+// T5 无时间窗口：无论多久前切过都按时间排队（不恢复 delay 原序）
+{
+  const c = { proxyPort: 5 };
+  c._switchHistory = new Map([["C", T0 - 3_600_000]]); // 1 小时前切过
+  const r = d._sortCandidates(nodes, c);
+  ok(r.join() === "A,B,D,C", "T5 无窗口：1 小时前切过仍沉底", r.join());
+}
+
+// T6 排序不改原数组
+{
+  ok(nodes.join() === "A,B,C,D", "T6 原数组未被修改");
+}
+
+// T7 _markSwitch 惰性初始化 + 更新
+{
+  const c = { proxyPort: 6 };
+  d._markSwitch(c, "A");
+  ok(
+    c._switchHistory instanceof Map && c._switchHistory.has("A"),
+    "T7 _markSwitch 惰性初始化并记录",
+  );
+  const t1 = c._switchHistory.get("A");
+  d._markSwitch(c, "A");
+  ok(c._switchHistory.get("A") >= t1, "T8 _markSwitch 重复记录更新时间戳");
+}
+
+// T9 时间戳相同时稳定排序（V8 sort 稳定，保持原相对序）
+{
+  const c = { proxyPort: 7 };
+  c._switchHistory = new Map([
+    ["A", T0 - 100],
+    ["B", T0 - 100],
+  ]);
+  const r = d._sortCandidates(nodes, c);
+  ok(r.join() === "C,D,A,B", "T9 相同时间戳保持原相对序（稳定排序）", r.join());
+}
+
+// T10 壳页判定：200 + 无跳转 + 无 error + 无 title → 壳页
+ok(
+  d._isShellPage({ error: null, httpCode: 200, numRedirects: 0, title: "" }) ===
+    true,
+  "T10 壳页判定：200+无title → true",
+);
+// T11 健康页（有 title）→ 非壳页
+ok(
+  d._isShellPage({
+    error: null,
+    httpCode: 200,
+    numRedirects: 0,
+    title: "TikTok - Make Your Day",
+  }) === false,
+  "T11 健康页有 title → false",
+);
+// T12 连接错误 → 非壳页
+ok(
+  d._isShellPage({
+    error: "timeout",
+    httpCode: 0,
+    numRedirects: 0,
+    title: "",
+  }) === false,
+  "T12 连接错误 → false",
+);
+// T13 跳转 → 非壳页
+ok(
+  d._isShellPage({ error: null, httpCode: 200, numRedirects: 1, title: "" }) ===
+    false,
+  "T13 跳转 → false",
+);
+// T14 非 200 → 非壳页
+ok(
+  d._isShellPage({ error: null, httpCode: 403, numRedirects: 0, title: "" }) ===
+    false,
+  "T14 非 200 → false",
+);
+
+console.log(`\n结果: ${pass} 通过 / ${fail} 失败`);
+process.exit(fail ? 1 : 0);

package/scripts/test-wmi-free-upgrade.mjs

@@ -0,0 +1,98 @@
+/**
+ * 测试：升级链绕开 WMI 的新逻辑（2026-08-21）
+ * 范围（macOS 可测部分）：
+ *  1. parseCsvLine：tasklist /FO CSV 输出解析（引号/逗号边界）
+ *  2. 模拟 tasklist /V 输出的窗口标题匹配过滤逻辑（复算与实现一致的筛选规则）
+ *  3. agent 构造即写存活标记文件（STARTED_FILE），内容含 pid/version
+ */
+import assert from "assert";
+import { readFileSync, rmSync } from "fs";
+import { join, dirname } from "path";
+import { tmpdir } from "os";
+import { fileURLToPath } from "url";
+
+const { parseCsvLine } = await import("../src/watchdog/upgrader.js");
+
+let pass = 0;
+const ok = (msg) => {
+  pass++;
+  console.log(`  ✓ ${msg}`);
+};
+
+// ── 1. parseCsvLine ──
+const L1 = '"conhost.exe","5234","Console","2","8,312 K","Running","x\\user","0:00:01","tt-help-watchdog (F-7@WIN)"';
+const f1 = parseCsvLine(L1);
+assert.strictEqual(f1[0], "conhost.exe", "映像名");
+assert.strictEqual(f1[1], "5234", "PID");
+assert.strictEqual(f1[3], "2", "会话#");
+assert.strictEqual(f1[4], "8,312 K", "带逗号字段 8,312 K");
+assert.strictEqual(f1[8], "tt-help-watchdog (F-7@WIN)", "窗口标题");
+ok("parseCsvLine: 常规行（含带逗号字段）");
+
+// 标题内含转义引号（CSV 标准：双引号 "" 转义）
+const L2 = '"cmd.exe","999","Console","2","1,024 K","Running","x\\user","0:00:00","say ""hi"", tt-help-watchdog"';
+const f2 = parseCsvLine(L2);
+assert.strictEqual(f2[8], 'say "hi", tt-help-watchdog', "标题含转义引号与逗号");
+ok("parseCsvLine: 标题含转义引号+逗号");
+
+// 无引号行（表头）
+const f3 = parseCsvLine("映像名称,PID,会话名,会话#,内存使用,状态,用户名,CPU 时间,窗口标题");
+assert.strictEqual(f3.length, 9, "表头 9 列");
+ok("parseCsvLine: 无引号表头");
+
+// ── 2. 模拟 tasklist /V 输出做标题匹配过滤（复算实现逻辑） ──
+const mockTasklist = [
+  '"映像名称","PID","会话名","会话#","内存使用","状态","用户名","CPU 时间","窗口标题"',
+  '"System Idle Process","0","Services","0","8 K","Unknown","NT AUTHORITY\\SYSTEM","1:23:45:55","N/A"',
+  '"conhost.exe","5234","Console","2","8,312 K","Running","x\\user","0:00:01","tt-help-watchdog (F-7@WIN-AADJ1HTCCAQ)"',
+  '"cmd.exe","4000","Console","2","4,444 K","Running","x\\user","0:00:00","N/A"',
+  '"conhost.exe","7777","Console","2","2,048 K","Running","x\\user","0:00:00","C:\\Windows\\system32\\cmd.exe"',
+  '"node.exe","6400","Console","2","120,000 K","Running","x\\user","0:00:10","N/A"',
+  '"cmd.exe","6401","Console","2","3,000 K","Running","x\\user","0:00:00","tt-help-watchdog (old)"',
+];
+const TAG = "tt-help-watchdog";
+const matched = [];
+for (const line of mockTasklist) {
+  if (!line.toLowerCase().includes(TAG.toLowerCase())) continue;
+  const fields = parseCsvLine(line);
+  if (fields.length < 2) continue;
+  const name = (fields[0] || "").toLowerCase();
+  if (!name.includes("conhost") && !name.includes("cmd")) continue;
+  const pid = parseInt(fields[1], 10);
+  if (pid > 0) matched.push(pid);
+}
+assert.deepStrictEqual(
+  [...new Set(matched)].sort((a, b) => a - b),
+  [5234, 6401],
+  "只匹配到标题含 tag 的 conhost/cmd，普通窗口/其他进程不误匹配",
+);
+ok("标题匹配过滤: 命中旧窗口 conhost+cmd，排除无关进程");
+
+// ── 3. agent 构造即写存活标记文件 ──
+const STARTED_FILE = join(tmpdir(), "tt-help-watchdog-started.json");
+rmSync(STARTED_FILE, { force: true });
+const { WatchdogAgent } = await import("../src/watchdog/agent.js");
+const agent = new WatchdogAgent({
+  serverUrl: "http://127.0.0.1:3001",
+  clientId: "test@unit",
+  intervalMs: 15000,
+});
+assert.ok(agent, "agent 构造成功");
+const st = JSON.parse(readFileSync(STARTED_FILE, "utf-8"));
+assert.strictEqual(st.pid, process.pid, "pid=当前进程");
+assert.ok(typeof st.version === "string" && st.version.length > 0, "version 非空");
+assert.ok(st.ts > 0, "ts 存在");
+ok(`存活文件写入: pid=${st.pid}, version=${st.version}`);
+
+// 重复构造覆盖写（模拟新版 watchdog 启动覆盖旧文件）
+const agent2 = new WatchdogAgent({
+  serverUrl: "http://127.0.0.1:3001",
+  clientId: "test2@unit",
+});
+const st2 = JSON.parse(readFileSync(STARTED_FILE, "utf-8"));
+assert.strictEqual(st2.pid, process.pid, "覆盖写仍有效");
+ok("存活文件: 重复构造覆盖写正常");
+
+// 清理测试文件
+rmSync(STARTED_FILE, { force: true });
+console.log(`\n全部通过: ${pass} 项`);

package/scripts/verify-kill-edge.mjs

@@ -0,0 +1,108 @@
+// verify-kill-edge.mjs — 在 Windows 上端到端验证 killEdgeProcesses（netstat 方案）
+// 场景模拟：业务开一个带 --remote-debugging-port 的 Edge 实例，
+// 看门狗关闭时调用 killEdgeProcesses(null, port) 杀浏览器。
+// 安全：只用独立端口 19222 + 独立 user-data-dir，不碰机器上其他 Edge。
+import { exec, execSync } from "node:child_process";
+
+const PKG =
+  process.env.APPDATA.replace(/\\/g, "/") +
+  "/npm/node_modules/tt-help-cli-ycl";
+const { killEdgeProcesses, parseNetstatListeningPids } = await import(
+  "file:///" + PKG + "/src/lib/browser/cdp.js"
+);
+
+const PORT = 19222;
+const USER_DATA_DIR =
+  process.env.TEMP.replace(/\\/g, "/") + "/edge-test-" + PORT;
+
+const delay = (ms) => new Promise((r) => setTimeout(r, ms));
+
+function netstatPids(port) {
+  const out = execSync("netstat -ano", {
+    encoding: "utf-8",
+    timeout: 5000,
+    windowsHide: true,
+  });
+  return parseNetstatListeningPids(out, port);
+}
+
+async function cleanup() {
+  const pids = netstatPids(PORT);
+  for (const pid of pids) {
+    try {
+      execSync(`taskkill /F /T /PID ${pid}`, {
+        stdio: "ignore",
+        windowsHide: true,
+      });
+    } catch {}
+  }
+  try {
+    execSync(`rd /s /q "${USER_DATA_DIR}"`, {
+      stdio: "ignore",
+      windowsHide: true,
+    });
+  } catch {}
+}
+
+async function main() {
+  // [1] 解析器静态验证：用当前真实 netstat 输出
+  {
+    const out = execSync("netstat -ano", {
+      encoding: "utf-8",
+      timeout: 5000,
+      windowsHide: true,
+    });
+    const sample = out
+      .split(/\r?\n/)
+      .filter((l) => l.includes("LISTENING"))
+      .slice(0, 5);
+    console.log("[1] 当前真实 LISTENING 行:");
+    for (const l of sample) console.log("   " + l.trim());
+    const clash = parseNetstatListeningPids(out, 9097);
+    console.log("[1] 9097 解析 PID = " + JSON.stringify(clash));
+  }
+
+  // [2] 启动真实 Edge CDP 测试实例
+  console.log("[2] 启动 Edge CDP 测试实例 (port=" + PORT + ") ...");
+  exec(
+    `start "" msedge --remote-debugging-port=${PORT} --user-data-dir="${USER_DATA_DIR}" --no-first-run --no-default-browser-check --disable-background-mode --disable-component-update --disable-crash-reporter --disable-breakpad --disable-sync --disable-background-networking`,
+    { windowsHide: true },
+  );
+
+  let readyPids = [];
+  for (let i = 0; i < 30; i++) {
+    await delay(1000);
+    readyPids = netstatPids(PORT);
+    if (readyPids.length > 0) break;
+  }
+  console.log("[2] 端口 " + PORT + " 监听 PID = " + JSON.stringify(readyPids));
+  if (readyPids.length === 0) {
+    console.log("RESULT: SETUP_FAIL（Edge 未监听端口）");
+    await cleanup();
+    process.exit(2);
+  }
+
+  // [3] 调用包内真实 killEdgeProcesses（与看门狗关闭时同一函数）
+  console.log("[3] 调用 killEdgeProcesses(null, " + PORT + ") ...");
+  const t0 = Date.now();
+  await killEdgeProcesses(null, PORT);
+  await delay(2000);
+
+  const after = netstatPids(PORT);
+  console.log(
+    "[3] 调用耗时 " +
+      (Date.now() - t0) +
+      "ms，杀后端口监听 PID = " +
+      JSON.stringify(after),
+  );
+
+  console.log(after.length === 0 ? "RESULT: PASS" : "RESULT: FAIL");
+  await cleanup();
+  process.exit(after.length === 0 ? 0 : 1);
+}
+
+main().catch(async (e) => {
+  console.error("脚本异常: " + e.message);
+  await cleanup();
+  process.exit(3);
+});