tt-help-cli-ycl 1.4.139 → 1.4.142

package/package.json

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

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

@@ -0,0 +1,176 @@
+/**
+ * 客户端异常监控单测（2026-08-28）
+ *
+ * 验证：
+ *   - detectClientError 检测函数：reportCount > 8 且最近一次上报在 2 分钟内
+ *   - 按 hostname 过滤本机条目；hostname 为空的旧条目不参与关联
+ *   - 命中 → onAlert 收到本机全部条目（含未命中条目）；未命中 → 不回调
+ *   - removeErrors 逐条 DELETE 并计数
+ *
+ * 运行: node --test scripts/test-client-error-monitor.mjs
+ */
+import { test, mock } from "node:test";
+import assert from "node:assert/strict";
+import os from "os";
+import {
+  detectClientError,
+  ClientErrorMonitor,
+} from "../src/watchdog/client-error-monitor.js";
+
+const HOST = os.hostname();
+
+function makeErr(overrides = {}) {
+  return {
+    userId: "u1",
+    hostname: HOST,
+    errorType: "consecutive_blocked",
+    reportCount: 10,
+    timestamp: Date.now() - 30_000,
+    ...overrides,
+  };
+}
+
+// ── 检测函数 ──
+
+test("D1 detectClientError：累计>8 且 2 分钟内 → 命中", () => {
+  assert.equal(
+    detectClientError(makeErr({ reportCount: 9 }), Date.now()),
+    true,
+  );
+});
+
+test("D2 detectClientError：reportCount=8 不命中（阈值是 >8）", () => {
+  assert.equal(
+    detectClientError(makeErr({ reportCount: 8 }), Date.now()),
+    false,
+  );
+});
+
+test("D3 detectClientError：最近上报超过 2 分钟 → 不命中", () => {
+  assert.equal(
+    detectClientError(
+      makeErr({ timestamp: Date.now() - 2 * 60_000 - 1 }),
+      Date.now(),
+    ),
+    false,
+  );
+});
+
+test("D4 detectClientError：缺 reportCount → 不命中", () => {
+  assert.equal(detectClientError({ timestamp: Date.now() }, Date.now()), false);
+});
+
+// ── 监控器 ──
+
+test("M1 按 hostname 过滤：他机条目不触发本机回调", async () => {
+  mock.method(globalThis, "fetch", async () => ({
+    ok: true,
+    json: async () => ({
+      clients: [makeErr({ hostname: "OTHER-MACHINE" })],
+    }),
+  }));
+  let alerted = false;
+  const m = new ClientErrorMonitor({
+    serverUrl: "http://127.0.0.1:3000",
+    hostname: HOST,
+    onAlert: async () => {
+      alerted = true;
+    },
+  });
+  const hit = await m._poll();
+  assert.equal(alerted, false, "他机异常不应回调");
+  assert.equal(hit, null, "无本机条目应返回 null");
+  mock.restoreAll();
+});
+
+test("M2 命中：onAlert 收到本机全部条目（含未命中条目）", async () => {
+  const mineHit = makeErr({ userId: "u-hit", reportCount: 10 });
+  const mineMiss = makeErr({ userId: "u-miss", reportCount: 2 });
+  const other = makeErr({ userId: "u-other", hostname: "OTHER-MACHINE" });
+  mock.method(globalThis, "fetch", async () => ({
+    ok: true,
+    json: async () => ({ clients: [mineHit, mineMiss, other] }),
+  }));
+  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, "命中 1 条");
+  assert.equal(hit[0].userId, "u-hit");
+  assert.equal(received.mine.length, 2, "回调收到本机全部 2 条");
+  assert.deepEqual(
+    received.mine.map((e) => e.userId).sort(),
+    ["u-hit", "u-miss"],
+    "回调含命中与未命中的本机条目",
+  );
+  mock.restoreAll();
+});
+
+test("M3 hostname 为空的旧条目不参与本机关联", async () => {
+  mock.method(globalThis, "fetch", async () => ({
+    ok: true,
+    json: async () => ({ clients: [makeErr({ hostname: "" })] }),
+  }));
+  let alerted = false;
+  const m = new ClientErrorMonitor({
+    serverUrl: "http://127.0.0.1:3000",
+    hostname: HOST,
+    onAlert: async () => {
+      alerted = true;
+    },
+  });
+  const hit = await m._poll();
+  assert.equal(alerted, false, "空 hostname 旧条目不应回调");
+  assert.equal(hit, null);
+  mock.restoreAll();
+});
+
+test("M4 removeErrors：逐条 DELETE 并计数", async () => {
+  const deleted = [];
+  mock.method(globalThis, "fetch", async (url, opts) => {
+    if (opts && opts.method === "DELETE") {
+      deleted.push(String(url));
+      return { ok: true };
+    }
+    return { ok: true, json: async () => ({ clients: [] }) };
+  });
+  const m = new ClientErrorMonitor({ serverUrl: "http://127.0.0.1:3000" });
+  const removed = await m.removeErrors([
+    { userId: "a" },
+    { userId: "b" },
+    { userId: "" },
+    null,
+  ]);
+  assert.equal(removed, 2, "有效 userId 各删一条");
+  assert.equal(deleted.length, 2, "共 2 次 DELETE");
+  assert.ok(
+    deleted.every((u) =>
+      ["a", "b"].some((id) => u.endsWith(`/api/client-error/${id}`)),
+    ),
+    "DELETE 路径正确",
+  );
+  mock.restoreAll();
+});
+
+test("M5 拉取失败静默：fetch 抛错不回调不崩溃", async () => {
+  mock.method(globalThis, "fetch", async () => {
+    throw new Error("ECONNREFUSED");
+  });
+  let alerted = false;
+  const m = new ClientErrorMonitor({
+    serverUrl: "http://127.0.0.1:3000",
+    hostname: HOST,
+    onAlert: async () => {
+      alerted = true;
+    },
+  });
+  const hit = await m._poll();
+  assert.equal(alerted, false);
+  assert.equal(hit, null);
+  mock.restoreAll();
+});

package/scripts/test-daemon-failover.mjs

@@ -5,6 +5,7 @@
  *   - 探针不健康 → 立即切换（无视冷却）
  *   - 探针健康（含壳页）→ 距上次切换 < 冷却期仅检查不切换
  *   - 探针健康 → 距上次切换 >= 冷却期 → 按业务级封禁轮换一次
+ *   - 强切（force=true）→ 探针健康且冷却期内仍强制轮换
  *   - 切换后（含手动/巡检/failover）更新 _lastSwitchAt 锚点，冷却期内不再切
  *   - 候选集为空 → 触发 delay 初测且不切换
  *
@@ -229,3 +230,15 @@ test("F9 disconnectMode=full：直接全断", async () => {
   assert.equal(state.idleCloses, 0, "full 模式不走优雅断连");
   assert.equal(state.closes, 1, "full 模式直接全断");
 });
+
+test("F10 强切（force）：冷却期内探针健康仍强制轮换", async () => {
+  resetState();
+  const { d, c } = makeCtx();
+  c._lastSwitchAt = Date.now(); // 刚切过，处于 10min 冷却期内
+  await d._handleFailover({ reason: "F10", force: true }, c);
+  assert.deepEqual(state.switches, ["🇲🇾 马来02"], "force 应无视冷却直接轮换");
+  assert.ok(
+    c._lastSwitchAt && c._lastSwitchAt > Date.now() - 5000,
+    "强切后应更新锚点（给新节点观察期）",
+  );
+});

package/scripts/test-proxy-switch-restart.mjs

@@ -0,0 +1,198 @@
+/**
+ * 代理切换 → watchdog 强制重启命令 链路测试（2026-08-28，先打通路版本）
+ *
+ * 验证：
+ *   T1  daemon _markSwitchTime 递增 restartSeq（首次为 1，连续递增）
+ *   T2  daemon _writeHealth 把 restartSeq 带进 health 文件
+ *   T3  daemon 未切换时 restartSeq 保持 0
+ *   T4  ProcessManager.restartAll 先停后起（真实子进程，pid 变化、数量恢复）
+ *   T5  restartAll 跳过 stopped / 无 child 的命令
+ *   T6  无运行命令时 restartAll 返回 {restarted:0}
+ *   T7  Agent._checkProxySwitch 首次读取仅建基线不触发
+ *   T8  health.restartSeq 变大 → 触发强制重启（真实子进程 pid 变化）
+ *   T9  health.restartSeq 变小（daemon 重启归零）→ 不触发
+ *   T10 通道重启：主文件 seq 不变时不触发
+ *
+ * 运行: node --test scripts/test-proxy-switch-restart.mjs
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { writeFileSync, rmSync, existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+const HEALTH_FILE = join(tmpdir(), "clash-health.json");
+
+/** 清理并写 health 文件（模拟 daemon 写入） */
+function writeHealthFile(extra) {
+  writeFileSync(
+    HEALTH_FILE,
+    JSON.stringify(
+      {
+        node: "🇺🇸 美国01",
+        healthy: true,
+        lastCheck: new Date().toISOString(),
+        ...extra,
+      },
+      null,
+      2,
+    ),
+  );
+}
+
+/** 生成一个常驻假命令（测试业务进程） */
+function fakeCmd(id) {
+  return {
+    id,
+    name: id,
+    command: process.execPath,
+    args: ["-e", "setInterval(()=>{},1000)"],
+    enabled: true,
+  };
+}
+
+function cleanup() {
+  try {
+    rmSync(HEALTH_FILE, { force: true });
+  } catch {}
+}
+
+test("T1-T3: daemon 切换信号（_markSwitchTime 递增 + _writeHealth 带出）", async () => {
+  const { ClashDaemon } = await import("../src/clash/daemon.js");
+  const ipc = await import("../src/clash/ipc.js");
+  cleanup();
+  try {
+    const d = new ClashDaemon({ dryRun: true });
+    const c = { proxyPort: 0 };
+
+    // T3: 未切换 → restartSeq = 0
+    d._writeHealth(c, { node: "A", healthy: true });
+    let h = ipc.readHealth(0);
+    assert.equal(h.restartSeq, 0, "未切换时 restartSeq 应为 0");
+
+    // T1: 首次切换 → 1
+    d._markSwitchTime(c);
+    assert.equal(c._restartSeq, 1, "首次切换 restartSeq 应为 1");
+    d._markSwitchTime(c);
+    assert.equal(c._restartSeq, 2, "连续切换 restartSeq 递增");
+
+    // T2: _writeHealth 带出 restartSeq
+    d._writeHealth(c, { node: "B", healthy: true, lastSwitch: "A → B" });
+    h = ipc.readHealth(0);
+    assert.equal(h.restartSeq, 2, "health 文件应携带 restartSeq=2");
+    assert.equal(h.lastSwitch, "A → B");
+  } finally {
+    cleanup();
+  }
+});
+
+test("T4-T6: ProcessManager.restartAll 先停后起", async () => {
+  const { ProcessManager } = await import("../src/watchdog/process-manager.js");
+  const pm = new ProcessManager();
+  try {
+    // T6: 空集
+    const empty = await pm.restartAll("测试");
+    assert.deepEqual(empty, { restarted: 0 }, "无运行命令应返回 0");
+
+    pm.startCommand(fakeCmd("proc-a"));
+    await new Promise((r) => setTimeout(r, 500));
+    assert.equal(pm.runningCount, 1);
+    const oldPid = pm.processes.get("proc-a").child.pid;
+
+    // T4: 先停后起，pid 变化、数量恢复
+    const r = await pm.restartAll("代理切换(测试)");
+    assert.equal(r.restarted, 1, "应重启 1 个命令");
+    assert.equal(pm.runningCount, 1, "重启后数量恢复");
+    const newPid = pm.processes.get("proc-a").child.pid;
+    assert.notEqual(newPid, oldPid, "重启后应是新进程（pid 不同）");
+
+    // T5: stopped 的命令不参与重启
+    pm.startCommand(fakeCmd("proc-b"));
+    await new Promise((r) => setTimeout(r, 500));
+    pm.stopCommand("proc-b");
+    const r2 = await pm.restartAll("二次重启");
+    assert.equal(r2.restarted, 1, "只重启 running 的 1 个，stopped 的不算");
+    assert.equal(pm.runningCount, 1);
+    assert.ok(!pm.processes.has("proc-b"), "proc-b 保持停止状态");
+  } finally {
+    pm.stopAll();
+  }
+});
+
+test("T7-T13: Agent._checkProxySwitch 感知切换（默认禁用，开启后才重启）", async () => {
+  const { WatchdogAgent } = await import("../src/watchdog/agent.js");
+  cleanup();
+  const agent = new WatchdogAgent({
+    serverUrl: "http://127.0.0.1:9",
+    clientId: "test-switch",
+    intervalMs: 60000,
+    spawnDaemon: false,
+  });
+  try {
+    // 准备一个运行中的假业务命令
+    agent.processManager.startCommand(fakeCmd("proc-c"));
+    await new Promise((r) => setTimeout(r, 500));
+    const pid0 = agent.processManager.processes.get("proc-c").child.pid;
+
+    // T7: 首次读取建基线，不触发
+    writeHealthFile({ restartSeq: 0, lastSwitch: "初始化" });
+    await agent._checkProxySwitch();
+    assert.equal(
+      agent.processManager.processes.get("proc-c").child.pid,
+      pid0,
+      "首次读取仅建基线，不应重启",
+    );
+
+    // T10: seq 不变不触发
+    writeHealthFile({ restartSeq: 0, lastSwitch: "初始化" });
+    await agent._checkProxySwitch();
+    assert.equal(
+      agent.processManager.processes.get("proc-c").child.pid,
+      pid0,
+      "seq 不变不应重启",
+    );
+
+    // T11: 默认禁用时 seq 变大 → 不触发（但基线已跟随更新）
+    writeHealthFile({ restartSeq: 1, lastSwitch: "禁用期间切换: A → B" });
+    await agent._checkProxySwitch();
+    assert.equal(
+      agent.processManager.processes.get("proc-c").child.pid,
+      pid0,
+      "默认禁用时检测到切换也不应重启",
+    );
+
+    // T12: 开启开关后，seq 仍为 1（无新切换）→ 不补触发历史切换
+    agent._applySwitchRestartConfig({ enabled: true });
+    await agent._checkProxySwitch();
+    assert.equal(
+      agent.processManager.processes.get("proc-c").child.pid,
+      pid0,
+      "开启开关后不应补触发开启前的历史切换",
+    );
+
+    // T8: 开启后 seq 1→2 → 触发强制重启
+    writeHealthFile({ restartSeq: 2, lastSwitch: "开启后切换: B → C" });
+    await agent._checkProxySwitch();
+    const pid1 = agent.processManager.processes.get("proc-c").child.pid;
+    assert.notEqual(pid1, pid0, "开启后检测到切换应强制重启（pid 变化）");
+    assert.equal(agent.processManager.runningCount, 1, "重启后数量恢复");
+
+    // T9: seq 变小（daemon 重启归零）→ 不触发
+    writeHealthFile({ restartSeq: 0, lastSwitch: "daemon 重启" });
+    await agent._checkProxySwitch();
+    assert.equal(
+      agent.processManager.processes.get("proc-c").child.pid,
+      pid1,
+      "seq 变小（daemon 重启归零）不应触发",
+    );
+
+    // T13: 归零后再次真实切换（0 → 1）应重新触发
+    writeHealthFile({ restartSeq: 1, lastSwitch: "再次切换: C → D" });
+    await agent._checkProxySwitch();
+    const pid2 = agent.processManager.processes.get("proc-c").child.pid;
+    assert.notEqual(pid2, pid1, "归零后再次切换应重新触发");
+  } finally {
+    await agent.stop();
+    cleanup();
+  }
+});