tt-help-cli-ycl 1.4.114 → 1.4.117

package/src/cli/attach.js

@@ -1,5 +1,6 @@
 import { TikTokScraper } from "../lib/tiktok-scraper.mjs";
 import { CDNBlockedError } from "../lib/parse-ssr.mjs";
+import { writeCommand } from "../clash/ipc.js";
 import {
   proxy as configuredProxy,
   userId as configuredUserId,
@@ -11,6 +12,8 @@ import v8 from "node:v8";
 
 const HEAP_RESTART_RATIO = 0.72;
 const MAX_TASK_BATCHES_BEFORE_RESTART = 200;
+const MAX_CDN_SWITCH_ATTEMPTS = 3; // 连续 CDN 限流最多切换几次节点，之后切换无效则改纯等待（账号/整体风控时切换无用）
+const MAX_CDN_COOLDOWN_SEC = 300; // CDN 冷却上限（指数退避：60s→120s→240s→300s）
 
 function formatNow() {
   return new Date().toLocaleString("zh-CN", {
@@ -147,8 +150,27 @@ export async function handleAttach(options) {
         body: JSON.stringify({ uniqueId }),
         signal: AbortSignal.timeout(30000),
       });
-      const data = await res.json();
-      if (!res.ok || data.error) return null;
+      let data = null;
+      try {
+        data = await res.json();
+      } catch {}
+      if (!res.ok) {
+        // CDN 限流：抛 CDNBlockedError，外层据此冷却（webserver 模式同样生效）
+        if (
+          data &&
+          typeof data.error === "string" &&
+          data.error.includes("CDN限流")
+        ) {
+          throw new CDNBlockedError(data.error);
+        }
+        // 其余失败（瞬时 503/5xx）返回 null，由服务端后续重新排队
+        return null;
+      }
+      // 业务结果：TikTok 明确 statusCode（209002 验证码等）→ 返回上层走"已记录"分支
+      if (data && data.error && data.tiktokStatusCode) {
+        return data;
+      }
+      if (data && data.error) return null;
       return data;
     };
   } else {
@@ -185,6 +207,7 @@ export async function handleAttach(options) {
     let loopCount = 0;
     let browserRestartCount = 0;
     let taskBatchCount = 0;
+    let consecutiveCdnBlocks = 0; // 连续 CDN 限流轮数（自适应：前几次切换节点，之后长等待）
 
     while (!shuttingDown) {
       loopCount++;
@@ -348,23 +371,47 @@ export async function handleAttach(options) {
 
       attachLog(`  本批结果: ${successCount} 成功, ${failCount} 失败\n`);
 
-      // CDN 限流比例超过 30% 时，冷却 + 重启浏览器（仅本地浏览器模式）
-      if (scraper) {
-        const cdnRatio = cdnBlockedCount / tasks.length;
-        if (cdnRatio > 0.3) {
-          const coolDownSeconds = cdnRatio > 0.8 ? 120 : 60;
+      // CDN 限流比例超过 30% 时：自适应策略（前几次切节点，连续限流则长等待）
+      const cdnRatio = tasks.length > 0 ? cdnBlockedCount / tasks.length : 0;
+      if (cdnRatio > 0.3) {
+        consecutiveCdnBlocks++;
+        // 冷却指数退避：60s→120s→240s→…上限 300s（切换后短等，持续限流则长等窗口过去）
+        const coolDownSeconds = Math.min(
+          60 * Math.pow(2, consecutiveCdnBlocks - 1),
+          MAX_CDN_COOLDOWN_SEC,
+        );
+        const shouldSwitch = consecutiveCdnBlocks <= MAX_CDN_SWITCH_ATTEMPTS;
+        if (shouldSwitch) {
+          // 用现有 IPC 接口通知 daemon 从候选集切下一个健康节点（换 IP 绕过 CDN 限流）
+          try {
+            writeCommand({
+              action: "failover",
+              reason: `attach CDN限流 连续${consecutiveCdnBlocks}次 (${(cdnRatio * 100).toFixed(0)}%)`,
+            });
+          } catch {}
+          attachLog(
+            `  [Attach] CDN限流比例 ${(cdnRatio * 100).toFixed(0)}% (${cdnBlockedCount}/${tasks.length})，第${consecutiveCdnBlocks}次连续限流，已通知 daemon 切换节点，冷却 ${coolDownSeconds} 秒...`,
+          );
+        } else {
+          // 连续多次切换仍限流 → 大概率账号/整体风控，切换无用，纯等待窗口过去
           attachLog(
-            `  [Attach] CDN限流比例 ${(cdnRatio * 100).toFixed(0)}% (${cdnBlockedCount}/${tasks.length})，冷却 ${coolDownSeconds} 秒后重启浏览器...`,
+            `  [Attach] CDN限流比例 ${(cdnRatio * 100).toFixed(0)}% (${cdnBlockedCount}/${tasks.length})，已连续 ${consecutiveCdnBlocks} 次切换仍限流（可能账号/整体风控），停止切换，长冷却 ${coolDownSeconds} 秒等待窗口过去...`,
           );
-          await new Promise((r) => setTimeout(r, coolDownSeconds * 1000));
+        }
+        await new Promise((r) => setTimeout(r, coolDownSeconds * 1000));
+        if (scraper) {
           await recycleScraper(
             scraper,
             `CDN限流比例过高 (${cdnBlockedCount}/${tasks.length})`,
           );
           browserRestartCount++;
-          taskBatchCount = 0;
         }
+        taskBatchCount = 0;
+      } else {
+        consecutiveCdnBlocks = 0; // 正常批次重置连续限流计数
+      }
 
+      if (scraper) {
         const heap = getHeapUsage();
         if (heap.ratio >= HEAP_RESTART_RATIO) {
           await recycleScraper(

package/src/cli/clash-daemon.js

@@ -1,7 +1,9 @@
 /**
  * clash-daemon CLI 命令入口
  *
- * 用法: tt-help clash-daemon [--interval 120] [--benchmark 10] [--country US] [--dry-run]
+ * 用法: tt-help clash-daemon [--interval 120] [--benchmark 10] [--country US]
+ *       [--api-port <端口>] [--secret <secret>] [--selection <策略>] [--config-path <路径>] [--dry-run]
+ * 控制端（端口/secret）默认自动发现，显式参数优先于自动发现
  */
 import { ClashDaemon } from "../clash/daemon.js";
 
@@ -14,6 +16,13 @@ export async function handleClashDaemon(options) {
       options["dry-run"] === "" ||
       options["dry-run"] === true ||
       process.argv.includes("--dry-run"),
+    apiPort: parseInt(options["api-port"]) || undefined,
+    secret: options.secret || undefined,
+    selection: options.selection || undefined,
+    configPaths:
+      Array.isArray(options["config-paths"]) && options["config-paths"].length
+        ? options["config-paths"]
+        : undefined,
   });
   await d.start();
 }

package/src/cli/precheck.js

@@ -1,5 +1,6 @@
 import { TikTokScraper } from "../lib/tiktok-scraper.mjs";
 import { CDNBlockedError } from "../lib/parse-ssr.mjs";
+import { writeCommand } from "../clash/ipc.js";
 import {
   proxy as configuredProxy,
   userId as configuredUserId,
@@ -163,8 +164,27 @@ export async function handlePrecheck(options) {
           body: JSON.stringify({ uniqueId }),
           signal: AbortSignal.timeout(30000),
         });
-        const data = await res.json();
-        if (!res.ok || data.error) return null;
+        let data = null;
+        try {
+          data = await res.json();
+        } catch {}
+        if (!res.ok) {
+          // CDN 限流：抛 CDNBlockedError，外层据此冷却（webserver 模式同样生效）
+          if (
+            data &&
+            typeof data.error === "string" &&
+            data.error.includes("CDN限流")
+          ) {
+            throw new CDNBlockedError(data.error);
+          }
+          // 其余失败（瞬时 503/5xx）返回 null，由服务端后续重新排队
+          return null;
+        }
+        // 业务结果：TikTok 明确 statusCode（209002 验证码等）→ 返回上层走"已记录"分支
+        if (data && data.error && data.tiktokStatusCode) {
+          return data;
+        }
+        if (data && data.error) return null;
         return data;
       };
     } else {
@@ -397,24 +417,32 @@ export async function handlePrecheck(options) {
         `  本轮结果: ${needRefreshCount} 需刷新, ${skipCount} 跳过, ${failCount} 失败`,
       );
 
-      // CDN 限流/堆内存/批次重启（仅本地浏览器模式）
-      if (scraper) {
-        const cdnRatio =
-          candidates.length > 0 ? cdnBlockedCount / candidates.length : 0;
-        if (cdnRatio > 0.3) {
-          const coolDownSeconds = cdnRatio > 0.8 ? 120 : 60;
-          precheckLog(
-            `  [Precheck] CDN限流比例 ${(cdnRatio * 100).toFixed(0)}% (${cdnBlockedCount}/${candidates.length})，冷却 ${coolDownSeconds} 秒后重启浏览器...`,
-          );
-          await new Promise((r) => setTimeout(r, coolDownSeconds * 1000));
+      // CDN 限流比例超过 30% 时：通知 clash daemon 故障切换（换出口 IP 绕过限流）+ 冷却
+      const cdnRatio =
+        candidates.length > 0 ? cdnBlockedCount / candidates.length : 0;
+      if (cdnRatio > 0.3) {
+        // 用现有 IPC 接口通知 daemon 从候选集切下一个健康节点（换 IP 绕过 CDN 限流）
+        try {
+          writeCommand({
+            action: "failover",
+            reason: `precheck CDN限流 (${(cdnRatio * 100).toFixed(0)}%)`,
+          });
+        } catch {}
+        // 切换节点后新 IP 生效需短暂等待，冷却可缩短（替代纯硬等 120s）
+        const coolDownSeconds = cdnRatio > 0.8 ? 90 : 60;
+        precheckLog(
+          `  [Precheck] CDN限流比例 ${(cdnRatio * 100).toFixed(0)}% (${cdnBlockedCount}/${candidates.length})，已通知 daemon 切换节点，冷却 ${coolDownSeconds} 秒...`,
+        );
+        await new Promise((r) => setTimeout(r, coolDownSeconds * 1000));
+        if (scraper) {
           await recycleScraper(
             scraper,
             `CDN限流比例过高 (${cdnBlockedCount}/${candidates.length})`,
           );
           browserRestartCount++;
-          taskBatchCount = 0;
         }
-
+        taskBatchCount = 0;
+      } else if (scraper) {
         const heap = getHeapUsage();
         if (heap.ratio >= HEAP_RESTART_RATIO) {
           await recycleScraper(

package/src/cli/refresh-mini.js

@@ -37,7 +37,6 @@ import {
   killEdgeProcesses,
 } from "../lib/browser/cdp.js";
 import { createApiClient } from "../lib/api-client.js";
-import { requireClashOrExit } from "../clash/checker.js";
 import { readHealth, writeCommand } from "../clash/ipc.js";
 import { spawn } from "child_process";
 import { fileURLToPath } from "url";
@@ -83,6 +82,19 @@ async function withRetry(label, fn) {
  */
 let spawnedDaemonPid = null;
 
+/** 从代理 URL 解析端口（http://127.0.0.1:7890 → 7890），无法解析返回 0（默认通道） */
+function proxyPortOf(url) {
+  if (!url) return 0;
+  try {
+    const u = new URL(url);
+    const p = parseInt(u.port, 10);
+    return p > 0 ? p : 0;
+  } catch {
+    const m = String(url).match(/:(\d+)/);
+    return m ? parseInt(m[1], 10) : 0;
+  }
+}
+
 function spawnClashDaemon() {
   try {
     const mainJs = path.join(__dirname, "..", "main.js");
@@ -115,10 +127,10 @@ function stopSpawnedDaemon() {
 }
 
 /**
- * 用 daemon 的 IPC 健康状态判断其是否存活（黑盒接口：clash-health.json）
+ * 用 daemon 的 IPC 健康状态判断其是否存活（黑盒接口：clash-health.json，按通道端口）
  */
-function isDaemonAlive() {
-  const h = readHealth();
+function isDaemonAlive(port = 0) {
+  const h = readHealth(port);
   return !!(h && !h.stale);
 }
 
@@ -140,20 +152,13 @@ export async function handleRefreshMini(options) {
     ensureDaemon,
   } = options;
 
+  // 配置了什么代理就用什么代理（--proxy > ~/.tt-help.json 的 proxy）；
+  // 未配置则不注入 proxyServer，浏览器走系统默认代理。
+  // 节点切换仍由 clash-daemon 负责（触发通知模式），不在此处自动解析。
   const effectiveProxy = exploreProxy || configuredProxy;
-  let resolvedProxy = effectiveProxy;
-  if (
-    !effectiveProxy ||
-    effectiveProxy.includes("127.0.0.1") ||
-    effectiveProxy.includes("localhost")
-  ) {
-    // refresh-mini 必须走本地 Clash：未配置代理时自动发现，节点轮换才有意义
-    resolvedProxy = await requireClashOrExit("refresh-mini");
-  } else {
-    console.error(
-      `[警告] 使用非本地代理 ${effectiveProxy}，Clash 节点轮换将无效`,
-    );
-  }
+  const resolvedProxy = effectiveProxy || null;
+  // 切换通知通道：按本实例的代理端口路由到 daemon 对应控制端
+  const proxyPort = proxyPortOf(resolvedProxy);
 
   let userId = exploreUserId || configuredUserId;
   let browser = null;
@@ -196,7 +201,7 @@ export async function handleRefreshMini(options) {
     if (exploreJobLocations) console.error(`任务国家: ${exploreJobLocations}`);
     console.error(`空闲间隔: ${exploreInterval || 30} 秒`);
     console.error(
-      `代理: ${resolvedProxy || "无"}${
+      `代理: ${resolvedProxy || "系统默认"}${
         rotateMin > 0
           ? `（每 ${rotateMin} 分钟轮换节点）`
           : "（定时轮换已关闭）"
@@ -310,8 +315,8 @@ export async function handleRefreshMini(options) {
 
     // --ensure-daemon：检查 clash-daemon 是否存活，未存活则拉起（默认不检测）
     if (ensureDaemon) {
-      if (isDaemonAlive()) {
-        const h = readHealth();
+      if (isDaemonAlive(proxyPort)) {
+        const h = readHealth(proxyPort);
         console.error(
           `[daemon] 已运行（上次巡检 ${h?.ageSeconds ?? "?"}s 前）`,
         );
@@ -339,16 +344,23 @@ export async function handleRefreshMini(options) {
       proxySwitchCount++;
       lastProxyTriggerTime = Date.now();
       consecutiveTaskErrors = 0;
-      const before = readHealth()?.lastSwitch || "";
+      const before = readHealth(proxyPort)?.lastSwitch || "";
       console.error(
-        `[代理] 触发切换通知（${reason}，累计 ${proxySwitchCount} 次），等待 daemon 回执...`,
+        `[代理] 触发切换通知（${reason}${proxyPort ? `，通道 ${proxyPort}` : ""}，累计 ${proxySwitchCount} 次），等待 daemon 回执...`,
+      );
+      writeCommand(
+        {
+          action: "failover",
+          reason: `refresh-mini: ${reason}`,
+          proxyPort: proxyPort || undefined,
+        },
+        proxyPort,
       );
-      writeCommand({ action: "failover", reason: `refresh-mini: ${reason}` });
 
       const deadline = Date.now() + SWITCH_RECEIPT_TIMEOUT_MS;
       while (Date.now() < deadline) {
         await sleep(3000);
-        const h = readHealth();
+        const h = readHealth(proxyPort);
         if (
           h &&
           h.lastSwitch &&

package/src/lib/args.js

@@ -758,6 +758,10 @@ function parseClashDaemonArgs(args) {
   let benchmark = 10;
   let dryRun = false;
   let country = null;
+  let apiPort = null;
+  let secret = null;
+  let selection = null;
+  const configPaths = [];
 
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -769,6 +773,15 @@ function parseClashDaemonArgs(args) {
       country = args[++i] || null;
     } else if (arg === "--dry-run") {
       dryRun = true;
+    } else if (arg === "--api-port") {
+      apiPort = parseInt(args[++i]) || 0;
+    } else if (arg === "--secret") {
+      secret = args[++i] || "";
+    } else if (arg === "--selection") {
+      selection = args[++i] || null;
+    } else if (arg === "--config-path") {
+      const p = args[++i];
+      if (p) configPaths.push(p);
     }
   }
 
@@ -778,6 +791,10 @@ function parseClashDaemonArgs(args) {
     benchmark,
     country,
     "dry-run": dryRun,
+    "api-port": apiPort,
+    secret,
+    selection,
+    "config-paths": configPaths,
     urls: [],
     outputFormat: "json",
     exploreCount: 0,

package/src/lib/constants.js

@@ -420,7 +420,7 @@ const HELP_TEXT = [
   "          tt-help watchdog -i 30 --client-id my-server-01",
   "",
   "  tt-help clash-daemon [选项]",
-  "    Clash Verge 代理节点健康守护：定时巡检 TikTok 可达性，异常时自动切换节点",
+  "    Clash Verge / mihomo 代理节点健康守护：定时巡检 TikTok 可达性，异常时自动切换节点",
   "    看门狗启动时会自动拉起此守护进程",
   "    选项:",
   "      --interval <秒>          巡检间隔，默认 120 秒（2分钟）",
@@ -428,6 +428,11 @@ const HELP_TEXT = [
   "      --country <国家代码>     只保留指定国家节点，默认不过滤",
   "                               支持: US, GB, DE, FR, JP, KR, SG, HK, TW, RU 等",
   "      --dry-run                只检测不切换（调试用）",
+  "      --api-port <端口>        控制 API 端口（默认自动发现；显式指定验证失败时报错）",
+  "      --secret <secret>        控制 API 密钥（默认自动获取）",
+  "      --selection <策略>       多控制端选择策略: system-proxy / preference / first-alive",
+  "      --config-path <路径>     追加自定义 config.yaml 探测路径（可重复）",
+  "    控制端自动发现: 依次探测 Clash Verge / 69cloud 配置 → 端口枚举，按策略选定",
   "    看门狗运行时可通过 /tmp/clash-cmd.json 发命令动态调整：",
   '      {"action":"switchNode","node":"节点名"}         一次性切换到指定节点（不干扰自检）',
   '      {"action":"setCountryFilter","country":"US"}   切换国家过滤',

package/src/watch/public/app.js

@@ -4055,23 +4055,41 @@ async function wdSetErrorTrigger() {
   }
 }
 
-// ── 代理节点区域（看门狗面板中每个客户端卡片） ──
+// ── 代理节点区域（看门狗面板中每个客户端卡片，支持多控制端通道） ──
 
 function renderProxySection(c, userId) {
+  var channels = c.clashHealthChannels || [];
+  if (channels.length > 0) {
+    var html = "";
+    for (var i = 0; i < channels.length; i++) {
+      html += renderProxyChannel(channels[i], userId);
+    }
+    return html;
+  }
+  // 兼容旧版：仅主控制端（legacy clashHealth）
   var h = c.clashHealth;
   if (!h || !h.node) return "";
-
   var nodes = (h.meta && h.meta.healthyNodes) || [];
   var hasNodes = nodes.length > 0;
+  return (
+    renderProxyLine(h, nodes, userId, 0, hasNodes) +
+    renderNodeList(nodes, h.node, userId, 0)
+  );
+}
 
+/** 单个控制端通道的代理区域 */
+function renderProxyChannel(ch, userId) {
+  if (!ch || !ch.node) return "";
+  var nodes = (ch.meta && ch.meta.healthyNodes) || [];
+  var hasNodes = nodes.length > 0;
   return (
-    renderProxyLine(h, nodes, userId, hasNodes) +
-    renderNodeList(nodes, h.node, userId, hasNodes)
+    renderProxyLine(ch, nodes, userId, ch.port || 0, hasNodes) +
+    renderNodeList(nodes, ch.node, userId, ch.port || 0)
   );
 }
 
 /** 代理状态行：当前节点 + 健康状态 + 展开按钮 */
-function renderProxyLine(h, nodes, userId, hasNodes) {
+function renderProxyLine(h, nodes, userId, port, hasNodes) {
   var dot = h.healthy ? "#4ade80" : "#f87171";
   var status = h.healthy
     ? (h.timeTotal || 0).toFixed(1) +
@@ -4079,19 +4097,31 @@ function renderProxyLine(h, nodes, userId, hasNodes) {
       ((h.sizeDownload || 0) / 1024).toFixed(0) +
       "KB"
     : h.error || "异常";
+  var clientTag = port
+    ? h.meta && h.meta.clientName
+      ? h.meta.clientName + " :" + port
+      : "代理 :" + port
+    : "";
 
   return styled(
     "div",
     "margin-top:6px;padding:6px 8px;background:#111;border-radius:6px;" +
       "display:flex;align-items:center;gap:8px;font-size:12px",
     styled("span", "color:" + dot + ";font-size:14px", "●") +
+      (clientTag
+        ? styled(
+            "span",
+            "color:#888;padding:0 4px;border:1px solid #333;border-radius:3px;font-size:10px",
+            clientTag,
+          )
+        : "") +
       styled("span", "color:#e0e0e0;font-weight:bold", h.node) +
       styled("span", "color:#666", "| " + status) +
       (hasNodes
         ? tag(
             "button",
             {
-              onclick: "wdToggleNodes('" + esc(userId) + "')",
+              onclick: "wdToggleNodes('" + esc(userId) + "'," + port + ")",
               style:
                 "margin-left:auto;padding:2px 8px;font-size:11px;background:#333;" +
                 "color:#60a5fa;border:1px solid #444;border-radius:3px;cursor:pointer",
@@ -4104,15 +4134,15 @@ function renderProxyLine(h, nodes, userId, hasNodes) {
 }
 
 /** 节点列表面板（默认隐藏） */
-function renderNodeList(nodes, currentNode, userId, hasNodes) {
-  if (!hasNodes) return "";
+function renderNodeList(nodes, currentNode, userId, port) {
+  if (!nodes || !nodes.length) return "";
 
   var items = "";
   for (var i = 0; i < nodes.length; i++) {
-    items += renderNodeItem(nodes[i], nodes[i] === currentNode, userId);
+    items += renderNodeItem(nodes[i], nodes[i] === currentNode, userId, port);
   }
 
-  var id = "wdNodes-" + wdEscId(userId);
+  var id = "wdNodes-" + wdEscId(userId) + "-" + port;
   return (
     '<div id="' +
     id +
@@ -4124,7 +4154,7 @@ function renderNodeList(nodes, currentNode, userId, hasNodes) {
 }
 
 /** 单个节点行 */
-function renderNodeItem(name, isActive, userId) {
+function renderNodeItem(name, isActive, userId, port) {
   var color = isActive ? "#4ade80" : "#888";
   var bg = isActive ? "background:#1a3a2a;" : "";
   var dot = isActive ? "●" : "○";
@@ -4135,7 +4165,9 @@ function renderNodeItem(name, isActive, userId) {
       esc(userId) +
       "','" +
       esc(name) +
-      "')\" " +
+      "'," +
+      port +
+      ')" ' +
       'style="margin-left:auto;padding:1px 6px;font-size:10px;background:#2563eb;' +
       'color:#fff;border:none;border-radius:2px;cursor:pointer">切换</button>';
 
@@ -4164,18 +4196,23 @@ function wdEscId(s) {
   return (s || "").replace(/[^a-zA-Z0-9_-]/g, "_");
 }
 
-function wdToggleNodes(userId) {
-  var el = document.getElementById("wdNodes-" + wdEscId(userId));
+function wdToggleNodes(userId, port) {
+  var el = document.getElementById(
+    "wdNodes-" + wdEscId(userId) + "-" + (port || 0),
+  );
   if (!el) return;
   el.style.display = el.style.display === "none" ? "block" : "none";
 }
 
-function wdSwitchNode(userId, node) {
+function wdSwitchNode(userId, node, port) {
+  var portLabel = port ? "（代理通道 " + port + "）" : "";
   if (
     !confirm(
       "确定要将 " +
         userId +
-        " 的代理切换到: " +
+        " 的代理" +
+        portLabel +
+        "切换到: " +
         node +
         " ？\n\n切换后自动巡检会继续运行。",
     )
@@ -4185,7 +4222,11 @@ function wdSwitchNode(userId, node) {
   fetch("/api/watchdog/switch-node", {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ userId: userId, node: node }),
+    body: JSON.stringify({
+      userId: userId,
+      node: node,
+      proxyPort: port || undefined,
+    }),
   })
     .then(function (r) {
       return r.json();

package/src/watch/watchdog-server.js

@@ -120,6 +120,7 @@ function getOnlineClients() {
       processes,
       llmAnalysis,
       clashHealth: info.clashHealth || null,
+      clashHealthChannels: info.clashHealthChannels || [],
       lastHeartbeat: info.lastHeartbeat,
       registeredAt: info.registeredAt,
       online,
@@ -324,6 +325,9 @@ async function handleHeartbeat(params, body, res) {
     config: body.config || {},
     processes: body.processes || [],
     clashHealth: body.clashHealth || null,
+    clashHealthChannels: Array.isArray(body.clashHealthChannels)
+      ? body.clashHealthChannels
+      : [],
   });
 
   // 按 userId 返回该客户端的专属命令列表
@@ -492,16 +496,22 @@ async function handleClearLlmAnalysis(params, body, res) {
 }
 
 async function handleSwitchNode(params, body, res) {
-  const { userId, node } = body || {};
+  const { userId, node, proxyPort } = body || {};
   if (!userId || !node) {
     sendJSON(res, 400, { error: "缺少 userId 或 node" });
     return;
   }
-  // 加入 Clash 命令队列，客户端下次心跳时取走
+  // 加入 Clash 命令队列，客户端下次心跳时取走（proxyPort 用于路由到对应控制端）
   const queue = clashCmdQueue.get(userId) || [];
-  queue.push({ action: "switchNode", node });
+  queue.push({
+    action: "switchNode",
+    node,
+    proxyPort: proxyPort ? Number(proxyPort) : undefined,
+  });
   clashCmdQueue.set(userId, queue);
-  console.error(`[watchdog] ${userId} 节点切换已入队: → ${node}`);
+  console.error(
+    `[watchdog] ${userId} 节点切换已入队: → ${node}${proxyPort ? ` (通道 ${proxyPort})` : ""}`,
+  );
   sendJSON(res, 200, { ok: true, message: `将在下次心跳时切换到 ${node}` });
 }
 

package/src/watchdog/agent.js

@@ -12,6 +12,7 @@ import {
   getClientConfig,
   getLocalIP,
   getClashHealth,
+  getClashHealthChannels,
 } from "./reporter.js";
 import { ProcessManager } from "./process-manager.js";
 import {
@@ -414,7 +415,8 @@ export class WatchdogAgent {
       config: getClientConfig(),
       processes: this.processManager.getProcessesStatus(),
       llmAnalysis: this._llmResults,
-      clashHealth: getClashHealth(), // daemon 写入的代理健康状态
+      clashHealth: getClashHealth(), // daemon 写入的主控制端健康状态（兼容旧版页面）
+      clashHealthChannels: getClashHealthChannels(), // 多控制端各通道健康状态
     };
   }
 
@@ -458,13 +460,21 @@ export class WatchdogAgent {
         }
       }
 
-      // 处理 Clash daemon 命令（一次写入数组，daemon 轮询整批处理）
+      // 处理 Clash daemon 命令（按 proxyPort 分组写入对应通道，无端口走默认通道）
       if (Array.isArray(data.clashCommands) && data.clashCommands.length > 0) {
         const ipc = await import("../clash/ipc.js");
-        ipc.writeCommand(data.clashCommands);
-        console.error(
-          `[watchdog] 下发 Clash 命令: ${JSON.stringify(data.clashCommands)}`,
-        );
+        const byPort = new Map();
+        for (const cmd of data.clashCommands) {
+          const port = cmd && cmd.proxyPort ? Number(cmd.proxyPort) : 0;
+          if (!byPort.has(port)) byPort.set(port, []);
+          byPort.get(port).push(cmd);
+        }
+        for (const [port, cmds] of byPort) {
+          ipc.writeCommand(cmds, port);
+          console.error(
+            `[watchdog] 下发 Clash 命令${port ? ` (通道 ${port})` : ""}: ${JSON.stringify(cmds)}`,
+          );
+        }
       }
 
       // 服务端下发的客户端配置（远程修改 ~/.tt-help.json）