tt-help-cli-ycl 1.4.82 → 1.4.83

package/package.json

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

package/src/clash/api.js

@@ -183,3 +183,34 @@ export async function switchToFastest(groupName) {
   }
   throw new Error("存活节点都不在目标组中");
 }
+
+/**
+ * 对单个节点测延迟（不切换当前选中节点）
+ * GET /proxies/{name}/delay?url=&timeout=
+ * @param {string} name - 节点名
+ * @param {string} url - 测速目标 URL
+ * @param {number} timeoutMs - 超时（毫秒）
+ * @returns {Promise<{delay:number, timeout:boolean}>} delay 毫秒，-1 表示失败；timeout=true 表示超时/不通
+ */
+export async function getProxyDelay(name, url, timeoutMs = 5000) {
+  try {
+    const qs = `url=${encodeURIComponent(url)}&timeout=${timeoutMs}`;
+    const res = await fetch(
+      `${BASE_URL}/proxies/${encodeURIComponent(name)}/delay?${qs}`,
+      {
+        headers: headers(),
+        signal: AbortSignal.timeout(timeoutMs + 5000),
+      },
+    );
+    if (res.status === 404) return { delay: -1, timeout: true };
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`HTTP ${res.status} ${res.statusText}: ${body}`);
+    }
+    const text = await res.text();
+    const data = text ? JSON.parse(text) : { delay: -1, timeout: true };
+    return { delay: data.delay ?? -1, timeout: data.timeout === true };
+  } catch {
+    return { delay: -1, timeout: true };
+  }
+}

package/src/clash/checker.js

@@ -62,12 +62,16 @@ let _proxyResolved = false;
 
 export async function resolveAndSetProxyUrl() {
   if (_proxyResolved) return CONFIG.proxyUrl;
-  try { CONFIG.proxyUrl = await api.resolveProxyUrl(); } catch {}
+  try {
+    CONFIG.proxyUrl = await api.resolveProxyUrl();
+  } catch {}
   _proxyResolved = true;
   return CONFIG.proxyUrl;
 }
 
-export function resetProxyUrlCache() { _proxyResolved = false; }
+export function resetProxyUrlCache() {
+  _proxyResolved = false;
+}
 
 // ══════════════════════════════════════════════
 // 2. 进程 / API 可达性检测
@@ -78,8 +82,10 @@ export function checkClashAlive() {
 }
 
 export function checkClashAliveWithReason() {
-  if (_detectProcess()) return { alive: true, reason: "verge-mihomo 进程已运行" };
-  if (_detectApi())    return { alive: true, reason: `API 端口 ${CONFIG.apiPort} 可达` };
+  if (_detectProcess())
+    return { alive: true, reason: "verge-mihomo 进程已运行" };
+  if (_detectApi())
+    return { alive: true, reason: `API 端口 ${CONFIG.apiPort} 可达` };
   return {
     alive: false,
     reason: `Clash Verge 未运行，或 API 端口 ${CONFIG.apiPort} 未开启（请在 Clash Verge 设置中开启"允许局域网连接"或"RESTful API"）`,
@@ -89,24 +95,36 @@ export function checkClashAliveWithReason() {
 function _detectProcess() {
   try {
     if (IS_WIN) {
-      const r = spawnSync("tasklist", ["/FI", "IMAGENAME eq verge-mihomo.exe", "/NH"],
-        { encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      const r = spawnSync(
+        "tasklist",
+        ["/FI", "IMAGENAME eq verge-mihomo.exe", "/NH"],
+        { encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] },
+      );
       return r.stdout?.includes("verge-mihomo.exe");
     }
-    const r = spawnSync("pgrep", ["-x", "verge-mihomo"],
-      { encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+    const r = spawnSync("pgrep", ["-x", "verge-mihomo"], {
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
     return r.status === 0 && !!r.stdout.trim();
-  } catch { return false; }
+  } catch {
+    return false;
+  }
 }
 
 function _detectApi() {
   try {
     const exe = IS_WIN ? "curl.exe" : "curl";
-    const r = spawnSync(exe, ["-s", "--max-time", "3",
-      `http://127.0.0.1:${CONFIG.apiPort}/version`],
-      { encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+    const r = spawnSync(
+      exe,
+      ["-s", "--max-time", "3", `http://127.0.0.1:${CONFIG.apiPort}/version`],
+      { encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] },
+    );
     return r.stdout.includes('"version"');
-  } catch { return false; }
+  } catch {
+    return false;
+  }
 }
 
 export async function requireClashOrExit(label = "") {
@@ -116,8 +134,12 @@ export async function requireClashOrExit(label = "") {
     console.error(`\n${pf}⚠ 代理不可用：${reason}`);
     console.error(`${pf}请先启动 Clash Verge 并确保：`);
     console.error(`  1. Clash Verge 正在运行（verge-mihomo 进程存活）`);
-    console.error(`  2. API 端口 ${CONFIG.apiPort} 已开启（设置 → 允许局域网连接 / RESTful API）`);
-    console.error(`  3. 代理端口 ${CONFIG.proxyUrl.replace("http://", "")} 正在监听\n`);
+    console.error(
+      `  2. API 端口 ${CONFIG.apiPort} 已开启（设置 → 允许局域网连接 / RESTful API）`,
+    );
+    console.error(
+      `  3. 代理端口 ${CONFIG.proxyUrl.replace("http://", "")} 正在监听\n`,
+    );
     process.exit(1);
   }
   return resolveAndSetProxyUrl();
@@ -133,16 +155,27 @@ export function checkNodeHealth(url = CONFIG.testUrl) {
   const title = _extractTitle(body);
   return {
     healthy: _isHealthyPage(error, httpCode, sizeDownload, title, body),
-    httpCode, timeTotal, sizeDownload, title, error,
+    httpCode,
+    timeTotal,
+    sizeDownload,
+    title,
+    error,
   };
 }
 
 function _curlViaProxy(url) {
   const args = [
-    "-s", "-w", "\n__CURL_META__%{http_code}|%{time_total}|%{size_download}",
-    "--proxy", CONFIG.proxyUrl,
-    "--max-time", String(CONFIG.curlTimeout),
-    "-L", "-A", CURL_UA, url,
+    "-s",
+    "-w",
+    "\n__CURL_META__%{http_code}|%{time_total}|%{size_download}",
+    "--proxy",
+    CONFIG.proxyUrl,
+    "--max-time",
+    String(CONFIG.curlTimeout),
+    "-L",
+    "-A",
+    CURL_UA,
+    url,
   ];
   const r = spawnSync("curl", args, {
     encoding: "utf-8",
@@ -153,15 +186,23 @@ function _curlViaProxy(url) {
   const out = r.stdout || "";
   const idx = out.lastIndexOf("__CURL_META__");
   return {
-    body:     idx >= 0 ? out.substring(0, idx).trimEnd() : "",
+    body: idx >= 0 ? out.substring(0, idx).trimEnd() : "",
     metaLine: idx >= 0 ? out.substring(idx + 13).trim() : "",
-    error:    r.error ? r.error.message : r.status !== 0 ? `curl exit ${r.status}` : null,
+    error: r.error
+      ? r.error.message
+      : r.status !== 0
+        ? `curl exit ${r.status}`
+        : null,
   };
 }
 
 function _parseCurlMeta(line) {
   const p = line.split("|");
-  return { httpCode: parseInt(p[0]) || 0, timeTotal: parseFloat(p[1]) || 0, sizeDownload: parseInt(p[2]) || 0 };
+  return {
+    httpCode: parseInt(p[0]) || 0,
+    timeTotal: parseFloat(p[1]) || 0,
+    sizeDownload: parseInt(p[2]) || 0,
+  };
 }
 
 function _extractTitle(body) {
@@ -170,9 +211,15 @@ function _extractTitle(body) {
 }
 
 function _isHealthyPage(error, httpCode, size, title, body) {
-  return !error && httpCode === 200 && size >= CONFIG.minPageSize &&
-    title.includes("TikTok") && !title.startsWith("About |") &&
-    !body.includes("SlardarWAF") && !body.includes("_wafchallengeid");
+  return (
+    !error &&
+    httpCode === 200 &&
+    size >= CONFIG.minPageSize &&
+    title.includes("TikTok") &&
+    !title.startsWith("About |") &&
+    !body.includes("SlardarWAF") &&
+    !body.includes("_wafchallengeid")
+  );
 }
 
 // ══════════════════════════════════════════════
@@ -180,8 +227,9 @@ function _isHealthyPage(error, httpCode, size, title, body) {
 // ══════════════════════════════════════════════
 
 export function filterNodesByCountry(nodes, country) {
-  if (!country || !COUNTRY_PATTERNS[country]) return { filtered: nodes, excluded: 0 };
-  const filtered = nodes.filter(n => COUNTRY_PATTERNS[country].test(n));
+  if (!country || !COUNTRY_PATTERNS[country])
+    return { filtered: nodes, excluded: 0 };
+  const filtered = nodes.filter((n) => COUNTRY_PATTERNS[country].test(n));
   return { filtered, excluded: nodes.length - filtered.length };
 }
 
@@ -189,6 +237,69 @@ export function getSupportedCountries() {
   return Object.keys(COUNTRY_PATTERNS);
 }
 
+// ══════════════════════════════════════════════
+// 4.5 delay 初测（零切换，生成候选集）
+// ══════════════════════════════════════════════
+
+/**
+ * 对 GLOBAL 组节点做 delay 初测（不切换当前节点）
+ * 并发测延迟，筛出可连通且延迟达标的节点，按延迟升序返回，作为故障切换的候选集
+ * @param {object} opts
+ * @param {string} [opts.country=null] - 国家过滤（默认 CONFIG.nodeCountryFilter）
+ * @param {number} [opts.timeoutMs=5000] - 单节点超时（毫秒）
+ * @param {number} [opts.thresholdMs=4000] - 延迟阈值（超过视为慢，不入选，毫秒）
+ * @param {number} [opts.concurrency=10] - 并发数
+ * @returns {Promise<{nodes:string[], total:number, results:Array}>}
+ */
+export async function runDelayProbe({
+  country = null,
+  timeoutMs = 5000,
+  thresholdMs = 4000,
+  concurrency = 10,
+} = {}) {
+  const filter = country || CONFIG.nodeCountryFilter;
+  let all = [];
+  try {
+    all = await api.listGroupNodes(CONFIG.groupName);
+  } catch (e) {
+    console.error(`[checker] 获取 GLOBAL 节点列表失败: ${e.message}`);
+    return { nodes: [], total: 0, results: [] };
+  }
+  const { filtered, excluded } = filterNodesByCountry(all, filter);
+  const total = all.length;
+
+  const results = [];
+  const queue = [...filtered];
+  async function worker() {
+    while (queue.length) {
+      const name = queue.shift();
+      const r = await api.getProxyDelay(name, CONFIG.testUrl, timeoutMs);
+      results.push({ node: name, delay: r.delay, timeout: r.timeout });
+    }
+  }
+  const workers = Array.from(
+    { length: Math.min(concurrency, Math.max(1, filtered.length)) },
+    () => worker(),
+  );
+  await Promise.all(workers);
+
+  const good = results
+    .filter((r) => !r.timeout && r.delay > 0 && r.delay <= thresholdMs)
+    .sort((a, b) => a.delay - b.delay);
+
+  const tag = filter
+    ? ` (${filter}节点 ${filtered.length}/${total}, 排除 ${excluded})`
+    : ` (${total} 个节点)`;
+  console.error(
+    `[checker] delay 初测完成: ${good.length}/${filtered.length} 个可达${tag}`,
+  );
+  return {
+    nodes: good.map((r) => r.node),
+    total: filtered.length,
+    results: good,
+  };
+}
+
 // ══════════════════════════════════════════════
 // 5. 健康节点列表持久化
 // ══════════════════════════════════════════════
@@ -200,7 +311,13 @@ export function loadHealthyList(country = null) {
     const allNodes = Array.isArray(d.nodes) ? d.nodes : [];
     const filter = country || CONFIG.nodeCountryFilter;
     const { filtered, excluded } = filterNodesByCountry(allNodes, filter);
-    return { updated: d.updated || "", nodes: filtered, totalNodes: allNodes.length, excluded, countryFilter: filter || null };
+    return {
+      updated: d.updated || "",
+      nodes: filtered,
+      totalNodes: allNodes.length,
+      excluded,
+      countryFilter: filter || null,
+    };
   } catch (e) {
     console.error(`[checker] 读取健康列表失败: ${e.message}`);
   }
@@ -209,15 +326,24 @@ export function loadHealthyList(country = null) {
 
 export function saveHealthyList(nodes) {
   try {
-    writeFileSync(HEALTHY_FILE,
-      JSON.stringify({ updated: new Date().toISOString(), nodes }, null, 2), "utf-8");
+    writeFileSync(
+      HEALTHY_FILE,
+      JSON.stringify({ updated: new Date().toISOString(), nodes }, null, 2),
+      "utf-8",
+    );
   } catch (e) {
     console.error(`[checker] 保存健康列表失败: ${e.message}`);
   }
 }
 
 function _emptyList() {
-  return { updated: "", nodes: [], totalNodes: 0, excluded: 0, countryFilter: null };
+  return {
+    updated: "",
+    nodes: [],
+    totalNodes: 0,
+    excluded: 0,
+    countryFilter: null,
+  };
 }
 
 // ══════════════════════════════════════════════
@@ -226,7 +352,7 @@ function _emptyList() {
 
 export function pickFailoverNode(currentNode, healthyNodes) {
   if (!healthyNodes?.length) return null;
-  const candidates = healthyNodes.filter(n => n !== currentNode);
+  const candidates = healthyNodes.filter((n) => n !== currentNode);
   if (!candidates.length) {
     console.error(`[checker] 无可用候选节点（共${healthyNodes.length}个）`);
     return null;
@@ -237,10 +363,12 @@ export function pickFailoverNode(currentNode, healthyNodes) {
 export async function switchToNode(nodeName) {
   try {
     await api.switchProxy(CONFIG.groupName, nodeName);
-    await new Promise(r => setTimeout(r, 600));
+    await new Promise((r) => setTimeout(r, 600));
     const current = await api.getCurrentNode(CONFIG.groupName);
     if (current !== nodeName) {
-      console.error(`[checker] 切换验证失败: 期望 ${nodeName}, 实际 ${current}`);
+      console.error(
+        `[checker] 切换验证失败: 期望 ${nodeName}, 实际 ${current}`,
+      );
       return false;
     }
     return true;
@@ -255,12 +383,16 @@ export async function switchToNode(nodeName) {
 // ══════════════════════════════════════════════
 
 export async function runHealthCheck() {
-  if (!checkClashAlive()) return { action: "skipped", detail: "Clash Verge 未运行" };
+  if (!checkClashAlive())
+    return { action: "skipped", detail: "Clash Verge 未运行" };
   await resolveAndSetProxyUrl();
 
   const health = checkNodeHealth();
   if (health.healthy) {
-    return { action: "ok", detail: `${health.timeTotal.toFixed(1)}s ${(health.sizeDownload / 1024).toFixed(0)}KB` };
+    return {
+      action: "ok",
+      detail: `${health.timeTotal.toFixed(1)}s ${(health.sizeDownload / 1024).toFixed(0)}KB`,
+    };
   }
 
   const reason = health.error
@@ -268,14 +400,19 @@ export async function runHealthCheck() {
     : `HTTP ${health.httpCode} ${(health.sizeDownload / 1024).toFixed(0)}KB "${health.title}"`;
 
   let currentNode;
-  try { currentNode = await api.getCurrentNode(CONFIG.groupName); }
-  catch (e) { return { action: "failed", detail: `无法获取当前节点: ${e.message}` }; }
+  try {
+    currentNode = await api.getCurrentNode(CONFIG.groupName);
+  } catch (e) {
+    return { action: "failed", detail: `无法获取当前节点: ${e.message}` };
+  }
 
   const { nodes } = loadHealthyList();
-  if (!nodes.length) return { action: "failed", detail: `${reason} — 健康列表为空` };
+  if (!nodes.length)
+    return { action: "failed", detail: `${reason} — 健康列表为空` };
 
   const target = pickFailoverNode(currentNode, nodes);
-  if (!target) return { action: "failed", detail: `${reason} — 无可用候选节点` };
+  if (!target)
+    return { action: "failed", detail: `${reason} — 无可用候选节点` };
 
   if (!(await switchToNode(target))) {
     return { action: "failed", detail: `${reason} → 切换到 ${target} 失败` };

package/src/clash/daemon.js

@@ -1,30 +1,24 @@
 /**
  * ClashDaemon — 代理节点健康守护
  *
- * 职责: 定时巡检 → 异常切换 → 基准测速 → IPC 上报
+ * 职责: 定时巡检 → 异常切换 → delay 初测生成候选集 → IPC 上报
  * 看门狗通过 /tmp/clash-cmd.json 下发命令，每 10s 轮询
  */
 
-import { spawn } from "child_process";
-import { join, dirname } from "path";
 import { fileURLToPath } from "url";
-import { readFileSync, existsSync } from "fs";
 import * as api from "./api.js";
 import * as checker from "./checker.js";
 import * as ipc from "./ipc.js";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
 // ══════════════════════════════════════════════
 // ClashDaemon
 // ══════════════════════════════════════════════
 
 export class ClashDaemon {
   constructor(opts = {}) {
-    this.intervalMs = (opts.intervalSec || 30) * 1000;
+    this.intervalMs = (opts.intervalSec || 120) * 1000;
     this.benchmarkMs = (opts.benchmarkMin || 40) * 60 * 1000;
     this.dryRun = !!opts.dryRun;
-    this.benchmarkScript = _findBenchmark();
     this._running = false;
     this._timers = [];
     this._benchmarkRunning = false;
@@ -68,7 +62,7 @@ export class ClashDaemon {
       : Infinity;
     const isStale = !list.nodes.length || ageMin >= this.benchmarkMs / 60000;
     this._log(
-      `${list.nodes.length ? `已加载 ${list.nodes.length} 个健康节点${isStale ? ` (已过期 ${ageMin}min，立即刷新)` : ""}` : "健康列表为空，将立即执行基准测速"}`,
+      `${list.nodes.length ? `已加载 ${list.nodes.length} 个候选节点${isStale ? ` (已过期 ${ageMin}min，立即刷新)` : ""}` : "候选集为空，将立即执行 delay 初测"}`,
     );
 
     await this._healthCheck();
@@ -76,9 +70,9 @@ export class ClashDaemon {
 
     const initial = isStale ? 5000 : this.benchmarkMs;
     setTimeout(() => {
-      this._runBenchmark();
+      this._runDelayProbe();
       this._timers.push(
-        setInterval(() => this._runBenchmark(), this.benchmarkMs),
+        setInterval(() => this._runDelayProbe(), this.benchmarkMs),
       );
     }, initial);
 
@@ -132,23 +126,48 @@ export class ClashDaemon {
       const reason =
         h.error || `HTTP ${h.httpCode} ${(h.sizeDownload / 1024).toFixed(0)}KB`;
       const { nodes } = checker.loadHealthyList();
-      const target = checker.pickFailoverNode(node, nodes);
-      if (!target) {
-        this._log(`✗ ${reason} — 无法切换`);
+      if (!nodes.length) {
+        this._log(`✗ ${reason} — 候选集为空，触发 delay 初测`);
+        await this._runDelayProbe();
         return;
       }
       if (this.dryRun) {
-        this._log(`[DRY-RUN] 应切换到 ${target}`);
+        this._log(`[DRY-RUN] 当前节点异常，候选: ${nodes.length} 个`);
         return;
       }
 
-      const switched = await checker.switchToNode(target);
-      if (!switched) {
-        this._log(`✗ ${reason} → 切换到 ${target} 失败`);
+      // 逐个切换候选 + 内容验证，第一个满足即采用
+      let target = null;
+      let h2 = null;
+      for (const cand of nodes) {
+        if (cand === node) continue;
+        this._log(`↺ 尝试候选: ${cand}`);
+        if (!(await checker.switchToNode(cand))) {
+          this._log(`  ↺ ${cand} 切换失败，下一个`);
+          continue;
+        }
+        h2 = checker.checkNodeHealth();
+        if (h2.healthy) {
+          target = cand;
+          break;
+        }
+        this._log(`  ↺ ${cand} 内容验证未通过，下一个`);
+      }
+
+      if (!target) {
+        // 全部候选不可用，恢复原节点
+        await checker.switchToNode(node).catch(() => {});
+        this._log(`✗ ${reason} — 候选全部不可用，恢复原节点`);
+        ipc.writeHealth({
+          node,
+          healthy: false,
+          error: `${reason} — 候选全部不可用`,
+          lastSwitch: "failover: 候选全部不可用",
+          meta: this._buildMeta(),
+        });
         return;
       }
 
-      const h2 = checker.checkNodeHealth();
       this._log(
         `⚠ ${node} → ${target} (${h2.timeTotal.toFixed(1)}s ${(h2.sizeDownload / 1024).toFixed(0)}KB)`,
       );
@@ -173,65 +192,34 @@ export class ClashDaemon {
     }
   }
 
-  // ── 基准测速 ──
+  // ── 候选集 delay 初测（零切换） ──
 
-  _runBenchmark() {
-    if (!this.benchmarkScript || this._benchmarkRunning) return;
+  async _runDelayProbe() {
+    if (this._benchmarkRunning) return;
     this._benchmarkRunning = true;
-    this._log("=== 基准测速开始 ===");
+    this._log("=== 节点 delay 初测开始（零切换） ===");
     const start = Date.now();
-    const child = spawn(
-      process.execPath,
-      [this.benchmarkScript, "--timeout", "12"],
-      { cwd: dirname(this.benchmarkScript), stdio: ["ignore", "pipe", "pipe"] },
-    );
-
-    let stderr = "";
-    child.stderr.on("data", (d) => {
-      stderr += d.toString();
-    });
-    child.on("close", (code) => {
-      this._benchmarkRunning = false;
+    try {
+      const r = await checker.runDelayProbe({
+        country: checker.CONFIG.nodeCountryFilter,
+      });
       const elapsed = ((Date.now() - start) / 1000).toFixed(0);
-      if (code !== 0) {
-        this._log(`=== 基准测速失败 (exit ${code}, ${elapsed}s) ===`);
-        return;
-      }
-      try {
-        const rp = join(dirname(this.benchmarkScript), "speedtest-result.json");
-        if (!existsSync(rp)) {
-          this._log("=== 基准测速完成但未找到结果文件 ===");
-          return;
-        }
-        const allNodes = (
-          JSON.parse(readFileSync(rp, "utf-8")).realNodes || []
-        ).map((r) => r.node);
-        if (!allNodes.length) {
-          this._log("=== 基准测速完成: 0 个健康节点 ===");
-          return;
-        }
-        checker.saveHealthyList(allNodes);
-        const { filtered, excluded } = checker.filterNodesByCountry(
-          allNodes,
-          checker.CONFIG.nodeCountryFilter,
-        );
-        this._meta.lastBenchmark = new Date().toISOString();
-        this._meta.healthyNodesTotal = allNodes.length;
-        this._meta.healthyNodesCount = filtered.length;
-        const tag = checker.CONFIG.nodeCountryFilter
-          ? ` (${checker.CONFIG.nodeCountryFilter}节点 ${filtered.length}个, 排除 ${excluded}个)`
-          : "";
+      checker.saveHealthyList(r.nodes);
+      this._meta.lastBenchmark = new Date().toISOString();
+      this._meta.healthyNodesTotal = r.total;
+      this._meta.healthyNodesCount = r.nodes.length;
+      if (r.nodes.length) {
         this._log(
-          `=== 基准测速完成 (${elapsed}s): ${allNodes.length} 个健康节点${tag} ===`,
+          `=== delay 初测完成 (${elapsed}s): ${r.nodes.length} 个可达节点 ===`,
         );
-      } catch (e) {
-        this._log(`解析结果失败: ${e.message}`);
+      } else {
+        this._log(`=== delay 初测完成 (${elapsed}s): 0 个可达节点 ===`);
       }
-    });
-    child.on("error", (err) => {
+    } catch (e) {
+      this._log(`delay 初测异常: ${e.message}`);
+    } finally {
       this._benchmarkRunning = false;
-      this._log(`基准测速异常: ${err.message}`);
-    });
+    }
   }
 
   // ── 命令轮询 ──
@@ -313,10 +301,10 @@ export class ClashDaemon {
     console.error("═".repeat(50));
     console.error("  Clash Verge 节点健康守护");
     console.error(
-      `  检测: ${checker.CONFIG.testUrl}  |  巡检: ${this.intervalMs / 1000}s  |  基准: ${this.benchmarkMs / 60000}min${filterTag}`,
+      `  检测: ${checker.CONFIG.testUrl}  |  巡检: ${this.intervalMs / 1000}s  |  候选刷新: ${this.benchmarkMs / 60000}min${filterTag}`,
     );
     console.error(
-      `  基准脚本: ${this.benchmarkScript || "(不可用)"}  |  模式: ${this.dryRun ? "DRY-RUN" : "正常"}`,
+      `  模式: ${this.dryRun ? "DRY-RUN（只检测不切换）" : "正常运行"}`,
     );
     console.error("═".repeat(50));
   }
@@ -354,8 +342,8 @@ function _buildCmdHandlers(daemon) {
       }
     },
     runBenchmark() {
-      daemon._log("📋 收到手动触发基准测速命令");
-      daemon._runBenchmark();
+      daemon._log("📋 收到手动刷新候选集命令");
+      daemon._runDelayProbe();
     },
     setInterval(cmd) {
       if (cmd.seconds > 0) {
@@ -367,29 +355,6 @@ function _buildCmdHandlers(daemon) {
   };
 }
 
-// ══════════════════════════════════════════════
-// 工具
-// ══════════════════════════════════════════════
-
-function _findBenchmark() {
-  for (const p of [
-    // 1. 包内 benchmark（npm publish 后 src/clash/benchmark/speedtest-tiktok.mjs）
-    join(__dirname, "benchmark", "speedtest-tiktok.mjs"),
-    // 2. 开发模式：clash-verge-explore 同级目录
-    join(
-      __dirname,
-      "..",
-      "..",
-      "..",
-      "clash-verge-explore",
-      "speedtest-tiktok.mjs",
-    ),
-    join(__dirname, "speedtest-tiktok.mjs"),
-  ])
-    if (existsSync(p)) return p;
-  return null;
-}
-
 // 直接运行时自动启动
 if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
   const args = process.argv.slice(2);

package/src/cli/clash-daemon.js

@@ -1,7 +1,7 @@
 /**
  * clash-daemon CLI 命令入口
  *
- * 用法: tt-help clash-daemon [--interval 30] [--benchmark 40] [--country US] [--dry-run]
+ * 用法: tt-help clash-daemon [--interval 120] [--benchmark 40] [--country US] [--dry-run]
  */
 import { ClashDaemon } from "../clash/daemon.js";
 

package/src/lib/args.js

@@ -664,7 +664,7 @@ function parseWatchdogArgs(args) {
 }
 
 function parseClashDaemonArgs(args) {
-  let interval = 30;
+  let interval = 120;
   let benchmark = 40;
   let dryRun = false;
   let country = null;
@@ -672,7 +672,7 @@ function parseClashDaemonArgs(args) {
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === "--interval") {
-      interval = parseInt(args[++i]) || 30;
+      interval = parseInt(args[++i]) || 120;
     } else if (arg === "--benchmark") {
       benchmark = parseInt(args[++i]) || 40;
     } else if (arg === "--country") {

package/src/lib/constants.js

@@ -392,8 +392,8 @@ const HELP_TEXT = [
   "    Clash Verge 代理节点健康守护：定时巡检 TikTok 可达性，异常时自动切换节点",
   "    看门狗启动时会自动拉起此守护进程",
   "    选项:",
-  "      --interval <秒>          巡检间隔，默认 30 秒",
-  "      --benchmark <分钟>       全量测速间隔，默认 40 分钟",
+  "      --interval <秒>          巡检间隔，默认 120 秒（2分钟）",
+  "      --benchmark <分钟>       候选集 delay 初测间隔，默认 40 分钟",
   "      --country <国家代码>     只保留指定国家节点，默认不过滤",
   "                               支持: US, GB, DE, FR, JP, KR, SG, HK, TW, RU 等",
   "      --dry-run                只检测不切换（调试用）",
@@ -401,7 +401,7 @@ const HELP_TEXT = [
   '      {"action":"switchNode","node":"节点名"}         一次性切换到指定节点（不干扰自检）',
   '      {"action":"setCountryFilter","country":"US"}   切换国家过滤',
   '      {"action":"setCountryFilter","country":null}    取消过滤',
-  '      {"action":"runBenchmark"}                      手动触发全量测速',
+  '      {"action":"runBenchmark"}                      手动刷新候选集（delay 初测）',
   '      {"action":"setInterval","seconds":60}         修改巡检间隔',
   "    示例: tt-help clash-daemon",
   "          tt-help clash-daemon --country US",