tt-help-cli-ycl 1.4.115 → 1.4.117

package/src/clash/daemon.js

@@ -1,8 +1,9 @@
 /**
- * ClashDaemon — 代理节点健康守护
+ * ClashDaemon — 代理节点健康守护（多控制端）
  *
- * 职责: 定时巡检 → 异常切换 → delay 初测生成候选集 → IPC 上报
- * 看门狗通过 /tmp/clash-cmd.json 下发命令，每 10s 轮询
+ * 职责: 定时巡检全部 mihomo 客户端 → 异常切换 → delay 初测生成候选集 → IPC 上报
+ * 多通道: 命令/健康文件按代理端口分通道（默认通道兼容 watchdog/旧调用方），
+ *         所有控制器操作经 _withLock 串行化（api/checker 为单活动上下文）
  */
 
 import { fileURLToPath } from "url";
@@ -10,6 +11,7 @@ import { normalizeCountries } from "./checker.js";
 import * as api from "./api.js";
 import * as checker from "./checker.js";
 import * as ipc from "./ipc.js";
+import { discoverAll, invalidateDiscoverCache } from "./discover.js";
 
 // ── 国家过滤辅助（normalizeCountries 由 checker.js 提供单一来源） ──
 /** 国家配置显示（数组 join） */
@@ -27,11 +29,23 @@ export class ClashDaemon {
     this.intervalMs = (opts.intervalSec || 120) * 1000;
     this.benchmarkMs = (opts.benchmarkMin || 10) * 60 * 1000; // 候选集刷新默认 10 分钟
     this.dryRun = !!opts.dryRun;
+    // 控制端发现参数（CLI 显式值优先，内部再合并 ~/.tt-help.json）
+    this._discoverOpts = {
+      apiPort: opts.apiPort,
+      secret: opts.secret,
+      selection: opts.selection,
+      configPaths: opts.configPaths,
+    };
+    this._apiFailCount = 0;
     this._running = false;
     this._timers = [];
-    this._waitTimer = null; // 等待 Clash 就绪的重试定时器
+    this._waitTimer = null; // 等待控制端就绪的重试定时器
     this._startedOnce = false; // 首次启动标记（banner/信号只打印注册一次）
-    this._benchmarkRunning = false;
+    // 多控制端：每个控制器独立上下文；所有控制器操作经 _withLock 串行化
+    this._controllers = [];
+    this._primary = null;
+    this._lock = Promise.resolve();
+    this._lastDiscoverKey = "";
     // 支持逗号分隔字符串（如 "US,JP"），便于 watchdog 以 --country 透传上次生效的多国配置
     let initCountriesRaw = opts.country;
     if (
@@ -54,6 +68,47 @@ export class ClashDaemon {
     this._cmdHandlers = _buildCmdHandlers(this);
   }
 
+  // ── 多控制端基础设施 ──
+
+  /** 控制器操作串行锁（api/checker 为全局单活动上下文，串行切换避免互相污染） */
+  _withLock(fn) {
+    const run = this._lock.then(fn, fn);
+    this._lock = run.catch(() => {});
+    return run;
+  }
+
+  /** 将全局 api/checker 上下文指向指定控制器 */
+  _useController(c) {
+    api.configure({ port: c.port, secret: c.secret });
+    checker.applyDiscovered({
+      port: c.port,
+      proxyUrl: c.proxyUrl,
+      proxyPort: c.proxyPort,
+    });
+    c._meta = c._meta || {};
+  }
+
+  /** 命令路由：按 proxyPort 找对应控制器，找不到回退主控制端 */
+  _routeController(cmd) {
+    if (cmd && cmd.proxyPort) {
+      const t = this._controllers.find(
+        (c) => c.proxyPort === Number(cmd.proxyPort),
+      );
+      if (t) return t;
+      this._log(
+        `📋 命令目标代理端口 ${cmd.proxyPort} 无对应控制端，回退主控制端`,
+      );
+    }
+    return this._primary;
+  }
+
+  /** 写通道健康状态（每端口一份；主控制端额外写默认文件兼容 watchdog） */
+  _writeHealth(c, state) {
+    const payload = { ...state, meta: this._buildMeta(c) };
+    ipc.writeHealth(payload, c.proxyPort || 0);
+    if (c === this._primary && c.proxyPort) ipc.writeHealth(payload, 0);
+  }
+
   // ── 生命周期 ──
 
   async start() {
@@ -67,64 +122,108 @@ export class ClashDaemon {
       this._setupSignals();
     }
 
-    // 等待 Clash 就绪（容错启动顺序：先启 watchdog 后开 Clash 控制端口也可正常工作）
-    // 以 API 控制端口为准：进程在但控制端口未开启时同样等待，避免误判后所有 API 操作失败
-    const alive = checker.checkClashApiAlive();
-    const reason = alive
-      ? `API 端口 ${checker.CONFIG.apiPort} 可达`
-      : `Clash 控制端口 ${checker.CONFIG.apiPort} 未开启`;
-    if (!alive) {
+    // ── 控制端自动发现（全部客户端：端口 + secret + 代理端口） ──
+    let discs;
+    try {
+      discs = await discoverAll(this._discoverOpts);
+    } catch (e) {
+      // 显式指定端口验证失败：报错并等待重试，不回退默认（逃生舱语义）
+      this._log(`⚠ 控制端发现失败: ${e.message}（10s 后重试）`);
+      ipc.writeHealth({
+        node: "?",
+        healthy: false,
+        error: `控制端发现失败: ${e.message}`,
+        meta: this._buildMeta(null),
+      });
+      this._running = false;
+      this._waitTimer = setTimeout(() => this.start(), 10_000);
+      return;
+    }
+    const seen = new Set();
+    this._controllers = discs.filter((d) => {
+      if (seen.has(d.port)) return false;
+      seen.add(d.port);
+      return true;
+    });
+    this._primary = this._controllers[0] || null;
+
+    // 控制端列表只在变化时打印（等待重试期间不刷屏）
+    const key =
+      this._controllers.map((c) => `${c.clientName}@${c.port}`).join(" | ") ||
+      "无";
+    if (this._lastDiscoverKey !== key) {
+      this._lastDiscoverKey = key;
+      for (const c of this._controllers) {
+        this._log(
+          `✓ 控制端[${c.proxyPort}]: ${c.clientName} @127.0.0.1:${c.port}（来源: ${c.source}${c.fallback ? "，回退默认值" : ""}）`,
+        );
+      }
+    }
+
+    // 就绪检查：至少一个控制端 API 可达（以 API 控制端口为准）
+    const aliveAny = await this._withLock(async () => {
+      for (const c of this._controllers) {
+        this._useController(c);
+        if (checker.checkClashApiAlive()) return true;
+      }
+      return false;
+    });
+    if (!aliveAny) {
       this._waitRetry = (this._waitRetry || 0) + 1;
-      // 前 3 次（约 30s）每次打印，之后每 6 次（约 1 分钟）打印一次，避免刷屏
       const shouldLog = this._waitRetry <= 3 || this._waitRetry % 6 === 0;
       if (shouldLog) {
         const waitedSec = this._waitRetry * 10;
-        this._log(`⚠ Clash 未就绪：${reason}（已等待 ${waitedSec}s）`);
         this._log(
-          `  等待 API 端口 ${checker.CONFIG.apiPort} 可用，10s 后重试（Clash 就绪后自动接入）...`,
+          `⚠ 未发现可用控制端（已等待 ${waitedSec}s），10s 后重试（客户端就绪后自动接入）...`,
         );
       }
       ipc.writeHealth({
         node: "?",
         healthy: false,
-        error: `等待 Clash 就绪: ${reason}`,
-        meta: this._buildMeta(),
+        error: "等待控制端就绪",
+        meta: this._buildMeta(null),
       });
       this._running = false;
       this._waitTimer = setTimeout(() => this.start(), 10_000);
       return;
     }
-    this._waitRetry = 0; // 就绪后重置等待计数
-    // 等待期间的重试定时器已触发，清理引用
+    this._waitRetry = 0;
     if (this._waitTimer) {
       this._waitTimer = null;
     }
-    const proxyUrl = await checker.resolveAndSetProxyUrl();
-    this._log(
-      `✓ Clash 已连接 (${reason}), 代理端口: ${proxyUrl.replace("http://", "")}`,
-    );
 
-    const list = checker.loadHealthyList();
-    const ageMin = list.updated
-      ? Math.round((Date.now() - new Date(list.updated).getTime()) / 60000)
-      : Infinity;
-    const isStale = !list.nodes.length || ageMin >= this.benchmarkMs / 60000;
-    this._log(
-      `${list.nodes.length ? `已加载 ${list.nodes.length} 个候选节点${isStale ? ` (已过期 ${ageMin}min，立即刷新)` : ""}` : "候选集为空，将立即执行 delay 初测"}`,
-    );
+    // 主控制端上下文初始化 + 候选集状态
+    let primaryStale = true;
+    await this._withLock(async () => {
+      this._useController(this._primary);
+      const proxyUrl = await checker.resolveAndSetProxyUrl();
+      this._log(
+        `✓ 主控制端: ${this._primary.clientName} (API ${this._primary.port}), 代理端口: ${proxyUrl.replace("http://", "")}`,
+      );
+      const list = checker.loadHealthyList();
+      const ageMin = list.updated
+        ? Math.round((Date.now() - new Date(list.updated).getTime()) / 60000)
+        : Infinity;
+      primaryStale = !list.nodes.length || ageMin >= this.benchmarkMs / 60000;
+      this._log(
+        `${list.nodes.length ? `已加载 ${list.nodes.length} 个候选节点${primaryStale ? ` (已过期 ${ageMin}min，立即刷新)` : ""}` : "候选集为空，将立即执行 delay 初测"}`,
+      );
+    });
 
-    await this._healthCheck();
-    this._timers.push(setInterval(() => this._healthCheck(), this.intervalMs));
+    await this._healthCheckAll();
+    this._timers.push(
+      setInterval(() => this._healthCheckAll(), this.intervalMs),
+    );
 
-    const initial = isStale ? 5000 : this.benchmarkMs;
+    const initial = primaryStale ? 5000 : this.benchmarkMs;
     setTimeout(() => {
-      this._runDelayProbe();
+      this._runDelayProbeAll();
       this._timers.push(
-        setInterval(() => this._runDelayProbe(), this.benchmarkMs),
+        setInterval(() => this._runDelayProbeAll(), this.benchmarkMs),
       );
     }, initial);
 
-    this._log("守护进程已启动");
+    this._log(`守护进程已启动（${this._controllers.length} 个控制端）`);
     this._pollCommands();
     this._timers.push(setInterval(() => this._pollCommands(), 10000));
   }
@@ -140,37 +239,46 @@ export class ClashDaemon {
     this._log("守护进程已停止");
   }
 
-  // ── 巡检 ──
+  // ── 巡检（每个控制端独立巡检，串行执行） ──
 
-  async _healthCheck() {
-    if (!this._running || this._benchmarkRunning) return;
+  _healthCheckAll() {
+    if (!this._running) return;
+    this._withLock(async () => {
+      for (const c of this._controllers) {
+        await this._healthCheckController(c);
+      }
+    }).catch((e) => this._log(`巡检异常: ${e.message}`));
+  }
+
+  async _healthCheckController(c) {
+    if (c._probing) return; // delay 初测中跳过本轮巡检
+    this._useController(c);
     try {
       if (!checker.checkClashAlive()) {
-        return ipc.writeHealth({
+        return this._writeHealth(c, {
           node: "?",
           healthy: false,
-          error: "Clash 未运行",
-          meta: this._buildMeta(),
+          error: `${c.clientName} 未运行`,
         });
       }
       const node = await api
         .getCurrentNode(checker.CONFIG.groupName)
         .catch(() => "?");
       const h = checker.checkNodeHealth();
-      ipc.writeHealth({
+      this._writeHealth(c, {
         node,
         healthy: h.healthy,
         httpCode: h.httpCode,
         timeTotal: h.timeTotal,
         sizeDownload: h.sizeDownload,
         title: h.title,
-        meta: this._buildMeta(),
       });
 
       if (h.healthy) {
+        c._apiFailCount = 0;
         if (Math.random() < 0.17)
           this._log(
-            `✓ ${h.timeTotal.toFixed(1)}s ${(h.sizeDownload / 1024).toFixed(0)}KB`,
+            `✓ [${c.proxyPort}] ${h.timeTotal.toFixed(1)}s ${(h.sizeDownload / 1024).toFixed(0)}KB`,
           );
         return;
       }
@@ -179,24 +287,37 @@ export class ClashDaemon {
         h.error || `HTTP ${h.httpCode} ${(h.sizeDownload / 1024).toFixed(0)}KB`;
       const { nodes } = checker.loadHealthyList();
       if (!nodes.length) {
-        this._log(`✗ 巡检异常 [${reason}] — 候选集为空，触发 delay 初测`);
-        await this._runDelayProbe();
+        // 候选集为空时初测有冷却：避免坏控制器（全部节点不可达）
+        // 每轮巡检都触发初测，霸占串行锁饿死其它控制端与命令处理
+        const gap = Date.now() - (c._lastProbeAt || 0);
+        if (gap >= this.benchmarkMs) {
+          this._log(
+            `✗ [${c.proxyPort}] 巡检异常 [${reason}] — 候选集为空，触发 delay 初测`,
+          );
+          await this._runDelayProbeController(c);
+        } else {
+          this._log(
+            `✗ [${c.proxyPort}] 巡检异常 [${reason}] — 候选集为空（初测冷却中 ${Math.round((this.benchmarkMs - gap) / 1000)}s）`,
+          );
+        }
         return;
       }
       if (this.dryRun) {
         this._log(
-          `[DRY-RUN] 当前节点 ${node} 异常 [${reason}]，候选: ${nodes.length} 个`,
+          `[DRY-RUN] [${c.proxyPort}] 当前节点 ${node} 异常 [${reason}]，候选: ${nodes.length} 个`,
         );
         return;
       }
 
-      this._log(`✗ 巡检异常 [${reason}]，开始从候选集切换 (当前 ${node})`);
+      this._log(
+        `✗ [${c.proxyPort}] 巡检异常 [${reason}]，开始从候选集切换 (当前 ${node})`,
+      );
       // 逐个切换候选 + 内容验证，第一个满足即采用
       let target = null;
       let h2 = null;
       for (const cand of nodes) {
         if (cand === node) continue;
-        this._log(`↺ 尝试候选: ${cand} [原因: ${reason}]`);
+        this._log(`↺ [${c.proxyPort}] 尝试候选: ${cand} [原因: ${reason}]`);
         if (!(await checker.switchToNode(cand))) {
           this._log(`  ↺ ${cand} 切换失败，下一个`);
           continue;
@@ -213,24 +334,25 @@ export class ClashDaemon {
         // 全部候选不可用，恢复原节点
         await checker.switchToNode(node).catch(() => {});
         await api.closeAllConnections().catch(() => {});
-        this._log(`✗ 恢复原节点 ${node}（原因: ${reason} — 候选全部不可用）`);
-        ipc.writeHealth({
+        this._log(
+          `✗ [${c.proxyPort}] 恢复原节点 ${node}（原因: ${reason} — 候选全部不可用）`,
+        );
+        this._writeHealth(c, {
           node,
           healthy: false,
           error: `${reason} — 候选全部不可用`,
           lastSwitch: `巡检恢复(${reason}): → ${node}`,
-          meta: this._buildMeta(),
         });
         return;
       }
 
       this._log(
-        `⚠ 节点切换 [巡检异常: ${reason}]: ${node} → ${target} (${h2.timeTotal.toFixed(1)}s ${(h2.sizeDownload / 1024).toFixed(0)}KB)`,
+        `⚠ [${c.proxyPort}] 节点切换 [巡检异常: ${reason}]: ${node} → ${target} (${h2.timeTotal.toFixed(1)}s ${(h2.sizeDownload / 1024).toFixed(0)}KB)`,
       );
       // 切换后断开所有旧连接：mihomo 不主动掐旧连接，浏览器 keep-alive 会继续走旧节点
       // 导致"时好时坏"（实测旧连接可存活 8+ 分钟），必须强制重建才即时生效
       await api.closeAllConnections().catch(() => {});
-      ipc.writeHealth({
+      this._writeHealth(c, {
         node: target,
         healthy: h2.healthy,
         httpCode: h2.httpCode,
@@ -238,25 +360,60 @@ export class ClashDaemon {
         sizeDownload: h2.sizeDownload,
         title: h2.title,
         lastSwitch: `巡检异常(${reason}): ${node} → ${target}`,
-        meta: this._buildMeta(),
       });
     } catch (e) {
-      this._log(`巡检异常: ${e.message}`);
-      ipc.writeHealth({
-        node: "?",
-        healthy: false,
-        error: e.message,
-        meta: this._buildMeta(),
+      this._log(`[${c.proxyPort}] 巡检异常: ${e.message}`);
+      this._writeHealth(c, { node: "?", healthy: false, error: e.message });
+      // API 连续失败时重新发现控制端（FR-7 失效重探）
+      this._maybeRediscover(e).catch(() => {});
+    }
+  }
+
+  /**
+   * API 连续失败时的控制端重发现
+   * 连续 2 次巡检异常触发一次完整重发现，防止端口漂移后失联
+   */
+  async _maybeRediscover(e) {
+    this._apiFailCount = (this._apiFailCount || 0) + 1;
+    if (this._apiFailCount < 2) return;
+    this._apiFailCount = 0;
+    invalidateDiscoverCache();
+    this._log(`API 连续失败，重新发现控制端... (${e?.message || e})`);
+    try {
+      const discs = await discoverAll(this._discoverOpts);
+      const seen = new Set();
+      this._controllers = discs.filter((d) => {
+        if (seen.has(d.port)) return false;
+        seen.add(d.port);
+        return true;
       });
+      this._primary = this._controllers[0] || null;
+      this._lastDiscoverKey = "";
+      this._log(
+        `✓ 重新选定 ${this._controllers.length} 个控制端: ${this._controllers.map((c) => `${c.clientName}@${c.port}`).join(", ") || "无"}`,
+      );
+    } catch (err) {
+      this._log(`重新发现控制端失败: ${err.message}`);
     }
   }
 
-  // ── 候选集 delay 初测（零切换） ──
+  // ── 候选集 delay 初测（每个控制端独立，零切换） ──
 
-  async _runDelayProbe() {
-    if (this._benchmarkRunning) return;
-    this._benchmarkRunning = true;
-    this._log("=== 节点 delay 初测开始（零切换） ===");
+  _runDelayProbeAll() {
+    if (!this._running) return;
+    this._withLock(async () => {
+      for (const c of this._controllers) {
+        await this._runDelayProbeController(c);
+      }
+    }).catch((e) => this._log(`delay 初测异常: ${e.message}`));
+  }
+
+  async _runDelayProbeController(c) {
+    if (c._probing) return;
+    c._probing = true;
+    c._lastProbeAt = Date.now();
+    this._useController(c);
+    this._log(`=== [${c.proxyPort}] 节点 delay 初测开始（零切换） ===`);
     const start = Date.now();
     try {
       const r = await checker.runDelayProbe({
@@ -264,64 +421,74 @@ export class ClashDaemon {
       });
       const elapsed = ((Date.now() - start) / 1000).toFixed(0);
       checker.saveHealthyList(r.nodes);
-      this._meta.lastBenchmark = new Date().toISOString();
-      this._meta.healthyNodesTotal = r.total;
-      this._meta.healthyNodesCount = r.nodes.length;
+      c._meta.lastBenchmark = new Date().toISOString();
+      c._meta.healthyNodesTotal = r.total;
+      c._meta.healthyNodesCount = r.nodes.length;
       if (r.nodes.length) {
         this._log(
-          `=== delay 初测完成 (${elapsed}s): ${r.nodes.length} 个可达节点 ===`,
+          `=== [${c.proxyPort}] delay 初测完成 (${elapsed}s): ${r.nodes.length} 个可达节点 ===`,
         );
       } else {
-        this._log(`=== delay 初测完成 (${elapsed}s): 0 个可达节点 ===`);
+        this._log(
+          `=== [${c.proxyPort}] delay 初测完成 (${elapsed}s): 0 个可达节点 ===`,
+        );
       }
     } catch (e) {
-      this._log(`delay 初测异常: ${e.message}`);
+      this._log(`[${c.proxyPort}] delay 初测异常: ${e.message}`);
     } finally {
-      this._benchmarkRunning = false;
+      c._probing = false;
     }
   }
 
-  // ── 命令轮询 ──
+  // ── 命令轮询（多通道：默认通道 + 每端口通道） ──
 
   _pollCommands() {
     if (!this._running) return;
-    try {
-      const cmds = ipc.readCommand();
-      if (!cmds) return;
-      for (const cmd of cmds) {
-        const handler = this._cmdHandlers[cmd.action];
-        if (handler) {
-          handler(cmd);
-        } else {
-          this._log(`📋 未知命令: ${JSON.stringify(cmd)}`);
+    this._withLock(async () => {
+      for (const ch of ipc.listCommandChannels()) {
+        let cmds = null;
+        try {
+          cmds = ipc.readCommand(ch);
+        } catch {}
+        if (!cmds) continue;
+        for (const cmd of cmds) {
+          const target = this._routeController(cmd);
+          this._useController(target);
+          const handler = this._cmdHandlers[cmd.action];
+          if (handler) {
+            await handler(cmd, target);
+          } else {
+            this._log(`📋 未知命令: ${JSON.stringify(cmd)}`);
+          }
         }
+        ipc.clearCommand(ch);
       }
-      ipc.clearCommand();
-    } catch {}
+    }).catch(() => {});
   }
 
-  async _handleSwitchNode(cmd) {
+  async _handleSwitchNode(cmd, c) {
     try {
       const before = await api
         .getCurrentNode(checker.CONFIG.groupName)
         .catch(() => "?");
-      this._log(`🔄 看门狗指令: 切换节点 → ${cmd.node} (当前: ${before})`);
+      this._log(
+        `🔄 看门狗指令: [${c.proxyPort}] 切换节点 → ${cmd.node} (当前: ${before})`,
+      );
       if (!(await checker.switchToNode(cmd.node))) {
         this._log("🔄 看门狗指令: 切换失败");
-        return ipc.writeHealth({
+        return this._writeHealth(c, {
           node: before,
           healthy: null,
           lastSwitch: `manual → ${cmd.node} (失败)`,
-          meta: this._buildMeta(),
         });
       }
       const h = checker.checkNodeHealth();
       // 切换后断开所有旧连接，浏览器立即重建到新节点（同巡检切换）
       await api.closeAllConnections().catch(() => {});
       this._log(
-        `🔄 看门狗指令: 切换完成 (${h.timeTotal.toFixed(1)}s ${(h.sizeDownload / 1024).toFixed(0)}KB, ${h.healthy ? "健康" : "异常"})`,
+        `🔄 看门狗指令: [${c.proxyPort}] 切换完成 (${h.timeTotal.toFixed(1)}s ${(h.sizeDownload / 1024).toFixed(0)}KB, ${h.healthy ? "健康" : "异常"})`,
       );
-      ipc.writeHealth({
+      this._writeHealth(c, {
         node: cmd.node,
         healthy: h.healthy,
         httpCode: h.httpCode,
@@ -329,7 +496,6 @@ export class ClashDaemon {
         sizeDownload: h.sizeDownload,
         title: h.title,
         lastSwitch: `manual: ${before} → ${cmd.node}`,
-        meta: this._buildMeta(),
       });
     } catch (e) {
       this._log(`🔄 看门狗指令异常: ${e.message}`);
@@ -340,17 +506,19 @@ export class ClashDaemon {
    * 看门狗指令: 主动故障切换（不依赖巡检发现，强制从候选集切下一个可用节点）
    * 用于业务进程连续报错（CDN限流/网络异常/封 IP 等）时换出口节点
    */
-  async _handleFailover(cmd) {
+  async _handleFailover(cmd, c) {
     try {
       const reason = (cmd && cmd.reason) || "看门狗主动故障切换";
       const node = await api
         .getCurrentNode(checker.CONFIG.groupName)
         .catch(() => "?");
-      this._log(`🔄 看门狗指令: 触发故障切换 [${reason}] (当前: ${node})`);
+      this._log(
+        `🔄 看门狗指令: [${c.proxyPort}] 触发故障切换 [${reason}] (当前: ${node})`,
+      );
       const { nodes } = checker.loadHealthyList();
       if (!nodes.length) {
         this._log("🔄 候选集为空，触发 delay 初测");
-        await this._runDelayProbe();
+        await this._runDelayProbeController(c);
         return;
       }
       // 逐个切换候选 + 内容验证，第一个满足即采用（跳过当前节点）
@@ -376,18 +544,17 @@ export class ClashDaemon {
         this._log(
           `✗ failover [${reason}] — 候选全部不可用，恢复原节点 ${node}`,
         );
-        return ipc.writeHealth({
+        return this._writeHealth(c, {
           node,
           healthy: false,
           error: `failover(${reason}): 候选全部不可用`,
           lastSwitch: `failover恢复(${reason}): → ${node}`,
-          meta: this._buildMeta(),
         });
       }
       this._log(`⚠ 节点切换 [${reason}]: ${node} → ${target}`);
       // 切换后断开所有旧连接，浏览器立即重建到新节点（同巡检切换）
       await api.closeAllConnections().catch(() => {});
-      ipc.writeHealth({
+      this._writeHealth(c, {
         node: target,
         healthy: h2.healthy,
         httpCode: h2.httpCode,
@@ -395,7 +562,6 @@ export class ClashDaemon {
         sizeDownload: h2.sizeDownload,
         title: h2.title,
         lastSwitch: `${reason}: ${node} → ${target}`,
-        meta: this._buildMeta(),
       });
     } catch (e) {
       this._log(`🔄 故障切换异常: ${e.message}`);
@@ -404,17 +570,20 @@ export class ClashDaemon {
 
   // ── helpers ──
 
-  _buildMeta() {
+  _buildMeta(c) {
+    const base = c && c._meta ? c._meta : this._meta;
     const list = checker.loadHealthyList();
-    Object.assign(this._meta, {
+    Object.assign(base, {
       proxyUrl: checker.CONFIG.proxyUrl,
+      apiPort: checker.CONFIG.apiPort,
+      clientName: c ? c.clientName || null : null,
       testUrl: checker.CONFIG.testUrl,
       countryFilter: checker.CONFIG.nodeCountryFilter,
       healthyNodesCount: list.nodes.length,
       healthyNodesTotal: list.totalNodes,
       healthyNodes: list.nodes.slice(0, 50),
     });
-    return this._meta;
+    return base;
   }
 
   _log(msg) {
@@ -466,7 +635,7 @@ function _buildCmdHandlers(daemon) {
       // 幂等：国家配置变化时才立即刷新候选集，避免每次心跳重复初测
       if (JSON.stringify(prev || []) !== JSON.stringify(next)) {
         daemon._log(`📋 国家变化，立即刷新候选集...`);
-        daemon._runDelayProbe().catch(() => {});
+        daemon._runDelayProbeAll().catch(() => {});
       }
     },
     setTestUrl(cmd) {
@@ -478,7 +647,7 @@ function _buildCmdHandlers(daemon) {
     },
     runBenchmark() {
       daemon._log("📋 收到手动刷新候选集命令");
-      daemon._runDelayProbe();
+      daemon._runDelayProbeAll();
     },
     setInterval(cmd) {
       if (cmd.seconds > 0) {
@@ -486,8 +655,8 @@ function _buildCmdHandlers(daemon) {
         daemon._log(`📋 巡检间隔: → ${cmd.seconds}s`);
       }
     },
-    switchNode: (cmd) => daemon._handleSwitchNode(cmd),
-    failover: (cmd) => daemon._handleFailover(cmd),
+    switchNode: (cmd, c) => daemon._handleSwitchNode(cmd, c),
+    failover: (cmd, c) => daemon._handleFailover(cmd, c),
   };
 }
 
@@ -496,10 +665,18 @@ if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
   const args = process.argv.slice(2);
   const getArg = (flag) =>
     args.includes(flag) ? args[args.indexOf(flag) + 1] : undefined;
+  const configPaths = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--config-path" && args[i + 1]) configPaths.push(args[++i]);
+  }
   new ClashDaemon({
     intervalSec: parseInt(getArg("--interval")) || undefined,
     benchmarkMin: parseInt(getArg("--benchmark")) || undefined,
     country: getArg("--country") || undefined,
     dryRun: args.includes("--dry-run"),
+    apiPort: parseInt(getArg("--api-port")) || undefined,
+    secret: getArg("--secret") || undefined,
+    selection: getArg("--selection") || undefined,
+    configPaths: configPaths.length ? configPaths : undefined,
   }).start();
 }