tt-help-cli-ycl 1.4.169 → 1.4.171

package/scripts/test-upgrade-spawn.mjs

@@ -1,179 +0,0 @@
-/**
- * 升级器进程级模拟测试（新版 spawn 方案）
- *
- * 结构：假全局包 tt-help-cli-ycl（package.json version 9.9.9 + 假 cli.js 保持存活）
- *   → 假旧 watchdog A（SIGTERM 优雅退出）
- *   → 真 U（upgrader.js --upgrade --old-pid A）
- *   → 假 npm（FAKE_PKG/FAKE_VER 环境变量把 package.json version 改为 9.9.10）
- *   → U：下载(假 npm 改版本) → 验证(9.9.10) → 杀 A → spawn 新版 B(detached) → 存活确认
- *
- * 断言：
- *   - U 日志：验证通过 / 旧已退出 / 新版已启动 / 存活确认
- *   - A 已退出
- *   - B 进程存活（detached，U 退出后仍活）
- *
- * 用法：node scripts/test-upgrade-spawn.mjs
- */
-import {
-  mkdtempSync,
-  writeFileSync,
-  copyFileSync,
-  chmodSync,
-  mkdirSync,
-  rmSync,
-  realpathSync,
-} from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-import { spawn, execFileSync } from "child_process";
-
-const SRC = "/Users/yinchengliang/soft/tiktok/tiktok-cli";
-const REAL_NPM = execFileSync("which npm", { shell: true }).toString().trim();
-const tmp = mkdtempSync(join(tmpdir(), "tt-upgrade-test-"));
-const pkgDir = join(tmp, "pkg", "node_modules", "tt-help-cli-ycl");
-mkdirSync(join(pkgDir, "src", "watchdog"), { recursive: true });
-mkdirSync(join(tmp, "bin"), { recursive: true });
-
-let passed = 0,
-  failed = 0;
-function check(name, cond, detail = "") {
-  if (cond) {
-    passed++;
-    console.log(`  ✅ ${name}`);
-  } else {
-    failed++;
-    console.log(`  ❌ ${name} ${detail}`);
-  }
-}
-
-// ── 准备假全局包 ──
-writeFileSync(
-  join(pkgDir, "package.json"),
-  JSON.stringify({ name: "tt-help-cli-ycl", version: "9.9.9" }, null, 2),
-);
-writeFileSync(
-  join(pkgDir, "cli.js"),
-  `console.log("[fake-B] 新版 watchdog 启动 pid="+process.pid); setInterval(()=>{},1000); process.on("SIGTERM",()=>process.exit(0));`,
-);
-copyFileSync(
-  join(SRC, "src/watchdog/upgrader.js"),
-  join(pkgDir, "src/watchdog/upgrader.js"),
-);
-
-// ── 假旧 watchdog A ──
-const fakeA = join(tmp, "fakeA.mjs");
-writeFileSync(
-  fakeA,
-  `console.log("[fake-A] 启动 pid="+process.pid); process.on("SIGTERM",()=>{console.log("[fake-A] 收到 SIGTERM 优雅退出");process.exit(0)}); setInterval(()=>{},1000);`,
-);
-
-// ── 假 npm ──
-const fakeNpm = join(tmp, "bin", "npm");
-writeFileSync(
-  fakeNpm,
-  `#!/bin/sh
-if [ "$1" = "install" ]; then
-  node -e "const fs=require('fs');const p=process.env.FAKE_PKG;const j=JSON.parse(fs.readFileSync(p,'utf8'));j.version=process.env.FAKE_VER;fs.writeFileSync(p,JSON.stringify(j,null,2)+'\\n');console.log('[fake-npm] 版本改为 '+j.version)"
-  exit 0
-fi
-exec "${REAL_NPM}" "$@"
-`,
-);
-chmodSync(fakeNpm, 0o755);
-
-console.log("── 启动假旧 watchdog A ──");
-const a = spawn(process.execPath, [fakeA], {
-  stdio: ["ignore", "pipe", "pipe"],
-});
-let aOut = "";
-a.stdout.on("data", (d) => (aOut += d));
-a.stderr.on("data", (d) => (aOut += d));
-await new Promise((r) => setTimeout(r, 800));
-
-console.log("── 启动真升级器 U ──");
-let uOut = "";
-// mac 上 /var→/private/var 是 symlink：spawn 参数必须用 realpath，
-// 否则 process.argv[1] ≠ import.meta.url 的真实路径，--upgrade 守卫不成立直接退出
-const upgraderReal = realpathSync(join(pkgDir, "src/watchdog/upgrader.js"));
-const u = spawn(
-  process.execPath,
-  [
-    upgraderReal,
-    "--upgrade",
-    "--old-pid",
-    String(a.pid),
-    "--server",
-    "http://127.0.0.1:3000",
-    "--client-id",
-    "test-client",
-    "--interval",
-    "15",
-  ],
-  {
-    env: {
-      ...process.env,
-      PATH: `${join(tmp, "bin")}:${process.env.PATH}`,
-      FAKE_PKG: join(pkgDir, "package.json"),
-      FAKE_VER: "9.9.10",
-    },
-    stdio: ["ignore", "pipe", "pipe"],
-  },
-);
-u.stdout.on("data", (d) => (uOut += d));
-u.stderr.on("data", (d) => (uOut += d));
-const uExit = await new Promise((res) => u.on("exit", (c) => res(c)));
-await new Promise((r) => setTimeout(r, 500)); // 等 B 起来
-
-console.log("\n──── 假 A 输出 ────\n" + aOut.trim());
-console.log("\n──── 升级器 U 输出 ────\n" + uOut.trim());
-console.log(`\nU 退出码: ${uExit}\n`);
-
-// 提取新版 B 的 pid
-const pidMatch = uOut.match(/新版 watchdog 已启动 \(pid=(\d+)\)/);
-const bPid = pidMatch ? Number(pidMatch[1]) : null;
-
-console.log("──── 断言 ────");
-check("U 正常退出（exit 0）", uExit === 0, `(实际 ${uExit})`);
-check("版本验证通过 (9.9.10)", /新版本验证通过 \(9\.9\.10\)/.test(uOut));
-check(
-  "旧 watchdog 已退出",
-  /旧 watchdog 已退出/.test(uOut),
-  uOut.includes("已退出")
-    ? ""
-    : uOut
-        .split("\n")
-        .filter((l) => l.includes("退出"))
-        .join("|"),
-);
-check("新版 watchdog 已启动", /新版 watchdog 已启动 \(pid=\d+\)/.test(uOut));
-check("新版存活确认", /新版 watchdog 存活确认/.test(uOut));
-check(
-  "假 A 已退出",
-  a.exitCode !== null || a.signalCode !== null,
-  `(exitCode=${a.exitCode} signal=${a.signalCode})`,
-);
-check(
-  "新版 B 进程存活",
-  bPid
-    ? (() => {
-        try {
-          process.kill(bPid, 0);
-          return true;
-        } catch {
-          return false;
-        }
-      })()
-    : false,
-  `(bPid=${bPid})`,
-);
-
-// 清理：杀 B（如还活着）
-if (bPid) {
-  try {
-    process.kill(bPid, "SIGKILL");
-  } catch {}
-}
-rmSync(tmp, { recursive: true, force: true });
-
-console.log(`\n结果: ${passed} 通过 / ${failed} 失败`);
-process.exit(failed ? 1 : 0);

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

@@ -1,409 +0,0 @@
-// 回归测试：webserver 错误分类（IP 风控 → CDN 自愈，重启竞态 → 不计连续错误）
-// 运行：node scripts/test-webserver-error-classify.mjs
-import assert from "node:assert/strict";
-import { createServer } from "node:http";
-import { spawn } from "node:child_process";
-import {
-  TikTokScraper,
-  classifyGotoError,
-} from "../src/lib/tiktok-scraper.mjs";
-import {
-  classifyError,
-  switchClashNode,
-  settleCooldownWindow,
-} from "../src/webserver/server.mjs";
-import { CDNBlockedError, TikTokStatusError } from "../src/lib/parse-ssr.mjs";
-import { configure, resetConfig } from "../src/clash/api.js";
-import { parseNetstatListeningPids } from "../src/lib/browser/cdp.js";
-import { findListeningPids, killListeningOnPort } from "../src/lib/port.js";
-
-let passed = 0;
-let failed = 0;
-const checks = [];
-function check(name, fn) {
-  checks.push({ name, fn });
-}
-
-async function runAll() {
-  for (const { name, fn } of checks) {
-    try {
-      await fn();
-      passed++;
-      console.error(`PASS ${name}`);
-    } catch (e) {
-      failed++;
-      console.error(`FAIL ${name}: ${e.message}`);
-    }
-  }
-  console.error(`\n结果: ${passed} 通过, ${failed} 失败`);
-  process.exitCode = failed > 0 ? 1 : 0;
-}
-
-// ---- classifyGotoError ----
-check("goto 非2xx + status=403 → CDNBlockedError 带状态码", () => {
-  const err = classifyGotoError(
-    "page.goto: net::ERR_HTTP_RESPONSE_CODE_FAILURE at view-source:https://www.tiktok.com/@x/video/1",
-    403,
-  );
-  assert.ok(err instanceof CDNBlockedError);
-  assert.equal(err.name, "CDNBlockedError");
-  assert.match(err.message, /status=403/);
-});
-
-check("goto 非2xx + status=429 → CDNBlockedError", () => {
-  const err = classifyGotoError(
-    "page.goto: net::ERR_HTTP_RESPONSE_CODE_FAILURE at view-source:https://x",
-    429,
-  );
-  assert.ok(err instanceof CDNBlockedError);
-  assert.match(err.message, /status=429/);
-});
-
-check("goto 非2xx + status=null → CDNBlockedError 标 unknown", () => {
-  const err = classifyGotoError(
-    "page.goto: net::ERR_HTTP_RESPONSE_CODE_FAILURE at view-source:https://x",
-    null,
-  );
-  assert.ok(err instanceof CDNBlockedError);
-  assert.match(err.message, /status=unknown/);
-});
-
-check("goto 非2xx + status=404 → TikTokStatusError（业务结果）", () => {
-  const err = classifyGotoError(
-    "page.goto: net::ERR_HTTP_RESPONSE_CODE_FAILURE at view-source:https://www.tiktok.com/@x/video/9",
-    404,
-  );
-  assert.ok(err instanceof TikTokStatusError);
-  assert.equal(err.statusCode, 404);
-});
-
-check("goto ERR_ABORTED → null（原样冒泡）", () => {
-  assert.equal(
-    classifyGotoError(
-      "page.goto: net::ERR_ABORTED at view-source:https://x",
-      null,
-    ),
-    null,
-  );
-});
-
-check("goto frame detached → null（原样冒泡）", () => {
-  assert.equal(
-    classifyGotoError("page.goto: net::ERR_ABORTED; maybe frame was detached?"),
-    null,
-  );
-});
-
-check("goto 非字符串 → null", () => {
-  assert.equal(classifyGotoError(undefined), null);
-  assert.equal(classifyGotoError(null), null);
-});
-
-// ---- classifyError ----
-check("CDNBlockedError → cdn/503/retryable/不计连续错误", () => {
-  const c = classifyError(new CDNBlockedError("CDN限流"));
-  assert.deepEqual(c, {
-    kind: "cdn",
-    status: 503,
-    retryable: true,
-    countConsecutive: false,
-  });
-});
-
-check("goto 包装的 CDNBlockedError → cdn", () => {
-  const err = classifyGotoError(
-    "page.goto: net::ERR_HTTP_RESPONSE_CODE_FAILURE at view-source:https://www.tiktok.com/@x/video/2",
-    403,
-  );
-  const c = classifyError(err);
-  assert.equal(c.kind, "cdn");
-  assert.equal(c.status, 503);
-});
-
-check("TikTokStatusError(404) → business/200/不计连续错误", () => {
-  const c = classifyError(new TikTokStatusError(404, "TikTok HTTP 404"));
-  assert.deepEqual(c, {
-    kind: "business",
-    status: 200,
-    retryable: false,
-    countConsecutive: false,
-    statusCode: 404,
-  });
-});
-
-check("Server is shutting down → shutdown/503/不计", () => {
-  const c = classifyError(new Error("Server is shutting down"));
-  assert.deepEqual(c, {
-    kind: "shutdown",
-    status: 503,
-    retryable: true,
-    countConsecutive: false,
-  });
-});
-
-check("Timeout → timeout/504/计", () => {
-  const c = classifyError(new Error("page.goto: Timeout 15000ms exceeded"));
-  assert.deepEqual(c, {
-    kind: "timeout",
-    status: 504,
-    retryable: true,
-    countConsecutive: true,
-  });
-});
-
-check("重启竞态产物 → browser/503/不计", () => {
-  const cases = [
-    "browserContext.newPage: Target page, context or browser has been closed",
-    "page.goto: net::ERR_ABORTED at view-source:https://www.tiktok.com/@x/video/3",
-    "page.goto: net::ERR_ABORTED; maybe frame was detached?",
-    "Cannot read properties of null (reading 'newPage')",
-    "Execution context was destroyed, most likely because of a navigation.",
-    "Protocol error (Page.navigate): Target closed.",
-  ];
-  for (const msg of cases) {
-    const c = classifyError(new Error(msg));
-    assert.equal(c.kind, "browser", msg);
-    assert.equal(c.status, 503, msg);
-    assert.equal(c.retryable, true, msg);
-    assert.equal(c.countConsecutive, false, msg);
-  }
-});
-
-check("未知错误 → unknown/500/计", () => {
-  const c = classifyError(new Error("some random parse failure"));
-  assert.deepEqual(c, {
-    kind: "unknown",
-    status: 500,
-    retryable: false,
-    countConsecutive: true,
-  });
-});
-
-// ---- TikTokScraper 关闭标记（重启竞态防护）----
-check("closing=true 时 _ensurePage 抛 Server is shutting down", async () => {
-  const s = new TikTokScraper({ poolSize: 1 });
-  s.closing = true;
-  await assert.rejects(() => s._ensurePage({}), /Server is shutting down/);
-});
-
-check("context=null 时 _ensurePage 抛 Server is shutting down", async () => {
-  const s = new TikTokScraper({ poolSize: 1 });
-  s.closing = false;
-  s.context = null;
-  await assert.rejects(() => s._ensurePage({}), /Server is shutting down/);
-});
-
-// ---- switchClashNode（mock Clash API，不碰真实 9097）----
-/** 起一个 mock Clash 控制端，返回处理函数闭包里的状态 */
-function startMockClash(handler) {
-  return new Promise((resolve) => {
-    const server = createServer((req, res) => {
-      const url = new URL(req.url, "http://127.0.0.1");
-      let body = "";
-      req.on("data", (c) => (body += c));
-      req.on("end", () => {
-        const reply = (status, data) => {
-          res.statusCode = status;
-          if (data === undefined) {
-            res.end();
-            return;
-          }
-          res.setHeader("Content-Type", "application/json");
-          res.end(JSON.stringify(data));
-        };
-        handler(req, url, body ? JSON.parse(body) : null, reply);
-      });
-    });
-    server.listen(0, "127.0.0.1", () => resolve(server));
-  });
-}
-
-check("switchClashNode：选第一个 delay 通过的候选并切换", async () => {
-  let switchedTo = null;
-  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.endsWith("/delay")) {
-      reply(200, { delay: 120, timeout: false });
-    } else if (req.method === "PUT" && url.pathname === "/proxies/GLOBAL") {
-      switchedTo = body.name;
-      reply(204);
-    } else {
-      reply(404, {});
-    }
-  });
-  const port = server.address().port;
-  configure({ port });
-  try {
-    const picked = await switchClashNode("测试切节点");
-    assert.equal(picked, "B"); // 跳过当前节点 A，选第一个探测通过的 B
-    assert.equal(switchedTo, "B");
-  } finally {
-    resetConfig();
-    await new Promise((r) => server.close(r));
-  }
-});
-
-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") {
-      reply(200, { now: "A", all: ["A", "B"] });
-    } else if (req.method === "GET" && url.pathname.endsWith("/delay")) {
-      reply(200, { delay: -1, timeout: true });
-    } else {
-      reply(404, {});
-    }
-  });
-  configure({ port: server.address().port });
-  try {
-    await assert.rejects(() => switchClashNode("测试"), /候选均探测不通/);
-  } 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") {
-      reply(200, { now: "A", all: ["A"] });
-    } else {
-      reply(404, {});
-    }
-  });
-  configure({ port: server.address().port });
-  try {
-    await assert.rejects(() => switchClashNode("测试"), /无候选节点/);
-  } finally {
-    resetConfig();
-    await new Promise((r) => server.close(r));
-  }
-});
-
-// ---- 端口占用清理 ----
-check("parseNetstatListeningPids：精确端口匹配（3000 不误匹配 30001）", () => {
-  const out = [
-    "  TCP    0.0.0.0:3000       0.0.0.0:0              LISTENING       1234",
-    "  TCP    0.0.0.0:30001      0.0.0.0:0              LISTENING       5678",
-    "  TCP    127.0.0.1:3000     0.0.0.0:0              LISTENING       1234",
-    "  TCP    [::]:3000          [::]:0                 LISTENING       4321",
-  ].join("\r\n");
-  assert.deepEqual(parseNetstatListeningPids(out, 3000), ["1234", "4321"]);
-});
-
-check("killListeningOnPort：杀掉占用端口的子进程并可重新监听", async () => {
-  // 先占一个随机端口拿到端口号，再释放
-  const holder = createServer();
-  await new Promise((r) => holder.listen(0, "127.0.0.1", r));
-  const port = holder.address().port;
-  await new Promise((r) => holder.close(r));
-
-  // spawn 独立子进程占住该端口
-  const child = spawn(
-    process.execPath,
-    [
-      "-e",
-      `require("http").createServer((q,s)=>s.end("ok")).listen(${port},"127.0.0.1");setInterval(()=>{},1000);`,
-    ],
-    { stdio: "ignore" },
-  );
-  await new Promise((r) => setTimeout(r, 800)); // 等子进程监听
-
-  // 确认端口确实被占用
-  const before = findListeningPids(port);
-  assert.ok(
-    before.includes(String(child.pid)),
-    `预期子进程 ${child.pid} 在监听 ${port}，实际: ${before.join(",")}`,
-  );
-
-  // 先注册 exit 监听（kill 后进程瞬间退出，后注册会丢失事件）
-  const exitedPromise = new Promise((resolve) => {
-    const t = setTimeout(() => resolve(false), 3000);
-    child.once("exit", () => {
-      clearTimeout(t);
-      resolve(true);
-    });
-  });
-
-  await killListeningOnPort(port);
-
-  const exited = await exitedPromise;
-  assert.equal(exited, true, "子进程应被杀死");
-
-  // 端口应可重新监听
-  const s2 = createServer();
-  await new Promise((r) => s2.listen(port, "127.0.0.1", r));
-  await new Promise((r) => s2.close(r));
-});
-
-// ---- 5 分钟窗口结算（只数限流窗口，成功请求不参与）----
-const WINDOW = 5 * 60 * 1000;
-check("settleCooldownWindow：无窗口 → 不结算原样返回", () => {
-  assert.deepEqual(settleCooldownWindow(0, 0, 1000, WINDOW, 2), {
-    shouldSwitch: false,
-    count: 0,
-    windowStartAt: 0,
-  });
-});
-check("settleCooldownWindow：窗口内 → 不结算原样返回", () => {
-  assert.deepEqual(
-    settleCooldownWindow(1, 1000, 1000 + WINDOW - 1, WINDOW, 2),
-    {
-      shouldSwitch: false,
-      count: 1,
-      windowStartAt: 1000,
-    },
-  );
-});
-check("settleCooldownWindow：超 5 分钟且限流窗口 ≥2 → 切换并重新计数", () => {
-  assert.deepEqual(
-    settleCooldownWindow(2, 1000, 1000 + WINDOW + 1, WINDOW, 2),
-    {
-      shouldSwitch: true,
-      count: 0,
-      windowStartAt: 0,
-    },
-  );
-});
-check("settleCooldownWindow：超 5 分钟但限流窗口 <2 → 重新计算不切换", () => {
-  assert.deepEqual(
-    settleCooldownWindow(1, 1000, 1000 + WINDOW + 1, WINDOW, 2),
-    {
-      shouldSwitch: false,
-      count: 0,
-      windowStartAt: 0,
-    },
-  );
-});
-
-await runAll();

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

@@ -1,98 +0,0 @@
-/**
- * 测试：升级链绕开 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} 项`);