tt-help-cli-ycl 1.4.162 → 1.4.164

package/package.json

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

package/src/clash/daemon.js

@@ -175,20 +175,31 @@ export class ClashDaemon {
 
   /**
    * 逐个尝试候选节点并内容验证（巡检/failover/白名单守卫共用切换循环）
+   * @param {object} [opts]
+   * @param {Set<string>} [opts.occupied] 同订阅其它实例已占用的节点（互斥避让）；
+   *   有空闲候选时跳过被占用节点；候选全被占/仅一个候选时放行（“只允许一个节点”例外）
    * @returns {{target: string|null, h2: object|null}} 第一个满足（健康或壳页）的候选；全部失败返回 {target:null}
    */
-  async _tryRotateCandidates(c, ordered, currentNode, reason = "") {
+  async _tryRotateCandidates(c, ordered, currentNode, reason = "", opts = {}) {
     const tag = reason ? ` [原因: ${reason}]` : "";
+    // 同订阅互斥: 计算空闲候选（排除被占用与当前节点）；全被占时不排除（放行）
+    const occ = opts.occupied || null;
+    const free = occ ? ordered.filter((x) => !occ.has(x) && x !== currentNode) : null;
     let target = null;
     let h2 = null;
     for (const cand of ordered) {
       if (cand === currentNode) continue;
+      if (free && free.length > 0 && !free.includes(cand)) {
+        this._log(`  ⏭ [${c.proxyPort}] ${cand} 被同订阅其它实例占用，跳过`);
+        continue;
+      }
       this._log(`↺ [${c.proxyPort}] 尝试候选: ${cand}${tag}`);
       if (!(await checker.switchToNode(cand))) {
         this._log(`  ↺ ${cand} 切换失败，下一个`);
         continue;
       }
       this._markSwitch(c, cand);
+      c._currentNode = cand; // 同订阅互斥: 维护当前节点内存快照
       h2 = checker.checkNodeHealth();
       if (h2.healthy || this._isShellPage(h2)) {
         target = cand;
@@ -199,6 +210,120 @@ export class ClashDaemon {
     return { target, h2 };
   }
 
+  // ── 同订阅节点互斥（同 URL 多实例不允许同时使用同一节点，除非无空闲可用节点） ──
+
+  /** 内置实例序号（proxyPort 推导；0 = 非内置段如外部 Verge，不参与互斥） */
+  _instanceIndexOf(c) {
+    const idx = (c?.proxyPort || 0) - DISCOVER_DEFAULTS.proxyPort + 1;
+    return idx >= 1 && idx <= RUNTIME_MAX_INSTANCES ? idx : 0;
+  }
+
+  /** 同 URL 订阅的同组其它实例控制器（before=true 仅序号比自己小的） */
+  _mutexPeers(c, beforeOnly = false) {
+    const idx = this._instanceIndexOf(c);
+    if (!idx) return [];
+    let stored;
+    try {
+      stored = runtime.readStoredSubscriptions();
+    } catch {
+      return [];
+    }
+    const myUrl = stored[idx - 1]?.url;
+    if (!myUrl) return [];
+    const out = [];
+    for (let i = 1; i <= stored.length; i++) {
+      if (i === idx || stored[i - 1]?.url !== myUrl) continue;
+      if (beforeOnly && i > idx) continue;
+      const peer = this._controllers.find((x) => this._instanceIndexOf(x) === i);
+      if (peer && peer !== c) out.push(peer);
+    }
+    return out;
+  }
+
+  /** 当前被同组其它实例占用的节点集合（无同组返回 null = 不启用避让） */
+  _occupiedNodes(c) {
+    const peers = this._mutexPeers(c);
+    if (!peers.length) return null;
+    const occ = new Set();
+    for (const p of peers) if (p._currentNode) occ.add(p._currentNode);
+    return occ.size ? occ : null;
+  }
+
+  /**
+   * 巡检常驻互斥对齐（与白名单守卫同口径，不受 failover 冷却约束）:
+   * 与序号更小的同组实例撞节点 → 自己让位（序号小的保留）；10 分钟防抖。
+   * 让位无空闲可用节点（候选全被占/全不可用）→ 保留现状，下轮再试。
+   * @returns {Promise<boolean>} true=已让位切换（调用方跳过自身 health 写入）
+   */
+  async _enforceMutex(c, node) {
+    if (!node || node === "?") return false;
+    const conflict = this._mutexPeers(c, true).find((p) => p._currentNode === node);
+    if (!conflict) return false;
+    if (Date.now() - (c._lastMutexAlignAt || 0) < 600_000) return false;
+    c._lastMutexAlignAt = Date.now();
+    this._log(
+      `🔒 [${c.proxyPort}] 同订阅互斥: 节点 ${node} 已被实例@${conflict.proxyPort} 占用，让位切换`,
+    );
+    const { nodes } = checker.loadHealthyList();
+    if (!nodes.length) return false;
+    const ordered = this._sortCandidates(nodes, c);
+    const { target, h2 } = await this._tryRotateCandidates(
+      c, ordered, node, "同订阅节点互斥", { occupied: this._occupiedNodes(c) },
+    );
+    if (!target) {
+      await checker.switchToNode(node).catch(() => {});
+      this._log(`🔒 [${c.proxyPort}] 互斥让位失败（无空闲可用节点），暂保留 ${node}`);
+      return false;
+    }
+    await this._disconnect(c);
+    this._markSwitchTime(c);
+    this._writeHealth(c, {
+      node: target,
+      healthy: h2.healthy,
+      httpCode: h2.httpCode,
+      timeTotal: h2.timeTotal,
+      sizeDownload: h2.sizeDownload,
+      title: h2.title,
+      lastSwitch: `同订阅互斥: ${node} → ${target}`,
+    });
+    return true;
+  }
+
+  /**
+   * 手动切换后让位: 同组其它实例若占用了新节点 → 挪它（用户显式意图优先，不挪切换者）
+   */
+  async _mutexYieldTo(c, node) {
+    for (const p of this._mutexPeers(c)) {
+      if (p._currentNode !== node || p._probing) continue;
+      this._useController(p);
+      this._log(
+        `🔒 [${p.proxyPort}] 同订阅互斥: 节点 ${node} 被手动切换给 [${c.proxyPort}]，让位`,
+      );
+      const { nodes } = checker.loadHealthyList();
+      if (!nodes.length) continue;
+      const ordered = this._sortCandidates(nodes, p);
+      const { target, h2 } = await this._tryRotateCandidates(
+        p, ordered, node, "同订阅互斥(手动让位)", { occupied: this._occupiedNodes(p) },
+      );
+      if (!target) {
+        await checker.switchToNode(node).catch(() => {});
+        continue;
+      }
+      await this._disconnect(p);
+      this._markSwitchTime(p);
+      this._writeHealth(p, {
+        node: target,
+        healthy: h2.healthy,
+        httpCode: h2.httpCode,
+        timeTotal: h2.timeTotal,
+        sizeDownload: h2.sizeDownload,
+        title: h2.title,
+        lastSwitch: `同订阅互斥(手动): ${node} → ${target}`,
+      });
+    }
+    this._useController(c); // 恢复切换者上下文
+  }
+
   /** 将全局 api/checker 上下文指向指定控制器 */
   _useController(c) {
     api.configure({ port: c.port, secret: c.secret });
@@ -486,8 +611,7 @@ export class ClashDaemon {
       const node = await api
         .getCurrentNode(checker.CONFIG.groupName)
         .catch(() => "?");
-
-      // 订阅信息 + 流量采样（随巡检周期，差分算速率）
+      if (node && node !== "?") c._currentNode = node; // 同订阅互斥: 维护当前节点内存快照
       c._subsSnapshot = await api.getSubscriptionSummaries().catch(() => null);
       const conn = await api.getConnections().catch(() => null);
       if (conn) {
@@ -555,25 +679,26 @@ export class ClashDaemon {
       }
 
       if (h.healthy) {
-        c._apiFailCount = 0;
         if (Math.random() < 0.17)
           this._log(
             `✓ [${c.proxyPort}] ${h.timeTotal.toFixed(1)}s ${(h.sizeDownload / 1024).toFixed(0)}KB`,
           );
-        // 白名单守卫：节点健康但不在咱们节点列表内（如人工在 Clash Verge 界面手动切换）→ 强制切回
-        await this._enforceWhitelist(c, node);
+        // 白名单守卫 + 同订阅互斥：节点健康但不在咱们节点列表内 → 强制切回；
+        // 与序号更小的同组实例撞节点 → 让位
+        if (await this._enforceWhitelist(c, node)) return;
+        if (await this._enforceMutex(c, node)) return;
         return;
       }
 
       // 空壳页（TikTok SSR 降级响应）：链路可用、浏览器会自行渲染，
       // 切换无收益且会打断业务连接，不触发切换
       if (this._isShellPage(h)) {
-        c._apiFailCount = 0;
         this._log(
           `~ [${c.proxyPort}] 空壳页（降级响应，链路正常），不切换 (${(h.sizeDownload / 1024).toFixed(0)}KB ${h.timeTotal.toFixed(1)}s)`,
         );
-        // 白名单守卫与主分支同口径：壳页=链路正常，但列表外节点仍不允许
+        // 白名单守卫与互斥：壳页=链路正常，但列表外节点仍不允许；撞节点让位同口径
         if (await this._enforceWhitelist(c, node)) return;
+        if (await this._enforceMutex(c, node)) return;
         return this._writeHealth(c, {
           node,
           healthy: true,
@@ -594,8 +719,9 @@ export class ClashDaemon {
         this._log(
           `~ [${c.proxyPort}] 复测恢复（首次异常: ${firstReason}），不切换`,
         );
-        // 白名单守卫：复测恢复同样守口径（列表外节点不允许）
+        // 白名单守卫与互斥：复测恢复同样守口径（列表外不允许；撞节点让位）
         if (await this._enforceWhitelist(c, node)) return;
+        if (await this._enforceMutex(c, node)) return;
         return this._writeHealth(c, {
           node,
           healthy: true,
@@ -638,13 +764,15 @@ export class ClashDaemon {
         `✗ [${c.proxyPort}] 巡检异常 [${reason}]，开始从候选集切换 (当前 ${node})`,
       );
       // 逐个切换候选 + 内容验证，第一个满足即采用
-      // 排序：切过的节点按切换时间沉底（后进后出），优先尝试"最久没被切过"的节点
+      // 排序：切过的节点按切换时间沉底（后进后出），优先尝试"最久没被切过"的节点；
+      // 同订阅互斥: 避开同组其它实例占用的节点
       const ordered = this._sortCandidates(nodes, c);
       const { target, h2 } = await this._tryRotateCandidates(
         c,
         ordered,
         node,
         reason,
+        { occupied: this._occupiedNodes(c) },
       );
 
       if (!target) {
@@ -720,6 +848,8 @@ export class ClashDaemon {
           d._subsSnapshot = old._subsSnapshot;
           d._applyResult = old._applyResult;
           d._lastProbeAt = old._lastProbeAt;
+          d._currentNode = old._currentNode;
+          d._lastMutexAlignAt = old._lastMutexAlignAt;
         }
         return true;
       });
@@ -776,6 +906,7 @@ export class ClashDaemon {
       ordered,
       node,
       "白名单守卫",
+      { occupied: this._occupiedNodes(c) },
     );
     if (!target) {
       // 与 failover/巡检切换口径一致：候选全部不可用时恢复原节点
@@ -926,9 +1057,12 @@ export class ClashDaemon {
       }
       this._markSwitch(c, cmd.node);
       this._markSwitchTime(c);
+      c._currentNode = cmd.node; // 同订阅互斥: 维护当前节点内存快照
       const h = checker.checkNodeHealth();
       // 切换后优雅断连：回收空闲连接，活跃放行（同巡检切换）
       await this._disconnect(c);
+      // 同订阅互斥: 让同组占用新节点的其它实例让位（用户显式意图优先，不挪切换者）
+      await this._mutexYieldTo(c, cmd.node);
       this._log(
         `🔄 看门狗指令: [${c.proxyPort}] 切换完成 (${h.timeTotal.toFixed(1)}s ${(h.sizeDownload / 1024).toFixed(0)}KB, ${h.healthy ? "健康" : "异常"})`,
       );
@@ -1014,13 +1148,15 @@ export class ClashDaemon {
         return;
       }
       // 逐个切换候选 + 内容验证，第一个满足即采用（跳过当前节点）
-      // 排序：切过的节点按切换时间沉底（后进后出），优先尝试"最久没被切过"的节点
+      // 排序：切过的节点按切换时间沉底（后进后出），优先尝试"最久没被切过"的节点；
+      // 同订阅互斥: 避开同组其它实例占用的节点
       const ordered = this._sortCandidates(nodes, c);
       const { target, h2 } = await this._tryRotateCandidates(
         c,
         ordered,
         node,
         reason,
+        { occupied: this._occupiedNodes(c) },
       );
       // 本次 failover 已尽力处置（成功切换或恢复原节点）：更新锚点，给新节点干净观察期
       this._markSwitchTime(c);

package/src/clash/runtime.js

@@ -78,12 +78,13 @@ const UI_MANIFEST = { file: "metacubexd-dist.tgz", sha256: "93eb334af7e37d213317
 
 /**
  * 内核/面板下载源（顺序 failover）:
- *   1. ~/.tt-help.json → clash.vendorBase 或环境变量 TT_VENDOR_BASE（覆盖）
- *   2. 配置的服务端（~/.tt-help.json → server）→ {server}/scripts/vendor
- *      （内网 watch 优先：213 等内网机器走内网下载，不绕公网）
- *   3. 自建服务器公网（201 watch 静态路由 /scripts/vendor，免鉴权）
- *   4. 自建服务器内网（农场机器直连）
- *   5. GitHub Releases（仅海外/兜底；农场不可达属预期）
+ *   1. ~/.tt-help.json → clash.vendorBase / 环境变量 TT_VENDOR_BASE（显式覆盖，逃生舱）
+ *   2. HTTPS 域名镜像（最优默认源：域名+TLS+CDN，比公网 IP 直连更稳）
+ *   3. 配置的服务端（~/.tt-help.json → server）→ {server}/scripts/vendor
+ *      （内网机器的 server 为内网地址，作为 CDN 不可达时的就近回退）
+ *   4. 自建服务器公网（201 watch 静态路由 /scripts/vendor，免鉴权）
+ *   5. 自建服务器内网（农场机器直连）
+ *   6. GitHub Releases（仅海外/兜底；农场不可达属预期）
  */
 export function vendorBases() {
   const urls = [];
@@ -95,6 +96,14 @@ export function vendorBases() {
     if (existsSync(cfgPath)) {
       const cfg = JSON.parse(readFileSync(cfgPath, "utf-8"));
       push(cfg?.clash?.vendorBase);
+    }
+  } catch {}
+  push(process.env.TT_VENDOR_BASE);
+  push("https://call.huochedejia.com/vendor");
+  try {
+    const cfgPath = join(homedir(), ".tt-help.json");
+    if (existsSync(cfgPath)) {
+      const cfg = JSON.parse(readFileSync(cfgPath, "utf-8"));
       const server = String(cfg?.server || "").replace(/\/+$/, "");
       // 显式配置的服务端地址 → 推导 vendor 下载源（未配置/非 http 则跳过，避免污染 127.0.0.1 默认值）
       if (/^https?:\/\//.test(server) && !/^https?:\/\/127\.0\.0\.1/.test(server)) {
@@ -102,7 +111,6 @@ export function vendorBases() {
       }
     }
   } catch {}
-  push(process.env.TT_VENDOR_BASE);
   push("http://117.71.53.99:17301/scripts/vendor");
   push("http://172.18.154.201:3001/scripts/vendor");
   push("https://github.com/MetaCubeX/mihomo/releases/download");
@@ -206,7 +214,33 @@ async function installCoreFromArt(artPath, entry, { log = () => {} } = {}) {
  * 确保内核二进制就位（多级获取: 本地缓存 → 包内 vendor → 服务器下载 → GitHub 兼底）
  * @returns {Promise<{ok:boolean, bin?:string, source?:string, error?:string}>}
  */
+// ── 自定义内核（老 CPU 机器用本机可用内核，如 Verge 的 verge-mihomo.exe） ──
+
+/**
+ * 自定义内核路径（~/.tt-help.json → clash.corePath）:
+ * 官方 mihomo 二进制与 CPU 不兼容的机器（如 AMD A8-6410，启动即 0xC0000005），
+ * 指定本机已验证可用的内核二进制（例：C:\Program Files\Clash Verge\verge-mihomo.exe）。
+ * 指定后跳过下载/sha256 校验，直接用该路径 spawn（-d/-f 仍指向我们的运行目录，配置/日志隔离不变）。
+ */
+export function customCorePath() {
+  try {
+    const cfgPath = join(homedir(), ".tt-help.json");
+    if (!existsSync(cfgPath)) return null;
+    const cfg = JSON.parse(readFileSync(cfgPath, "utf-8"));
+    const p = cfg?.clash?.corePath;
+    return p && existsSync(p) ? p : null;
+  } catch {
+    return null;
+  }
+}
+
 export async function ensureBinary({ log = () => {} } = {}) {
+  // 0) 自定义内核（clash.corePath，存在即用，跳过下载/校验）
+  const custom = customCorePath();
+  if (custom) {
+    log(`⚙ 使用自定义内核: ${custom}`);
+    return { ok: true, bin: custom, source: "custom" };
+  }
   const { bin } = runtimePaths();
   const entry = VENDOR_MANIFEST[platformKey()];
   if (!entry) return { ok: false, error: `不支持的平台: ${platformKey()}` };
@@ -446,7 +480,9 @@ export function buildConfig({ subscriptions, apiPort, secret, mixedPort }) {
         `  ${s.name}:`,
         "    type: http",
         `    url: ${s.url}`,
-        "    interval: 86400",
+        // 订阅文件+userinfo（subscription-userinfo 响应头）刷新周期: 1 小时。
+        // 同一订阅可配多实例，各自快照时刻不同；24h 周期会导致页面剩余流量显示差异巨大（214 实测一天差 447GB）
+        "    interval: 3600",
         `    path: ./providers/${s.name}.yaml`,
         "    proxy: DIRECT",
         "    health-check:",

package/src/watch/public/app.js

@@ -4779,6 +4779,10 @@ async function wdSaveProxySettings() {
       return s.trim();
     })
     .filter(Boolean);
+  if (lines.length > 8) {
+    alert("最多 8 条订阅（每条一个独立 mihomo 实例，超出部分无法巡检）；当前 " + lines.length + " 行");
+    return;
+  }
   try {
     var res = await fetch("/api/watchdog/set-proxy-settings", {
       method: "POST",

package/src/watch/public/index.html

@@ -786,7 +786,7 @@
     style="display:none;position:fixed;top:0;left:0;right:0;bottom:0;background:rgba(0,0,0,0.6);z-index:9999;align-items:center;justify-content:center">
     <div style="background:#1e1e2e;border:1px solid #333;border-radius:12px;padding:24px;width:90%;max-width:560px">
       <div style="font-size:16px;color:#fbbf24;margin-bottom:4px">🛜 代理订阅配置 — <span id="wdProxyUserId"></span></div>
-      <div style="color:#888;font-size:12px;margin-bottom:12px">每行一个订阅地址（http/https），<b style="color:#fbbf24">一行 = 一个独立 mihomo 实例</b>：按行序分配实例 1/2/3…，代理端口依次 127.0.0.1:7897、7898、7899…（API 管理端口 9097 起，同步 +1），业务命令用 --proxy 指定使用哪个端口（客户端卡片“代理订阅”总览表可查映射）。<br>保存后客户端下次心跳时自动热应用（约 15～30 秒）；订阅名按行序自动编号 sub-1、sub-2…，<b style="color:#f87171">在中间插入/删除行会使后续实例重新编号并重载配置</b>，建议只在末尾追加。临期（&lt;7天）或超量（剩余&lt;10%）在总览表中标红。</div>
+      <div style="color:#888;font-size:12px;margin-bottom:12px">每行一个订阅地址（http/https），<b style="color:#fbbf24">一行 = 一个独立 mihomo 实例，最多 8 行</b>；<b style="color:#fbbf24">同一地址可配置多行</b>（各自独立使用不同节点）：按行序分配实例 1/2/3…，代理端口依次 127.0.0.1:7897、7898、7899…（API 管理端口 9097 起，同步 +1），业务命令用 --proxy 指定使用哪个端口（客户端卡片“代理订阅”tabs 可查映射）。<br>保存后客户端下次心跳时自动热应用（约 15～30 秒）；订阅名按行序自动编号 sub-1、sub-2…，<b style="color:#f87171">在中间插入/删除行会使后续实例重新编号并重载配置</b>，建议只在末尾追加。临期（&lt;7天）或超量（剩余&lt;10%）在 tab 上标红。</div>
       <textarea id="wdProxySubsText" rows="6" placeholder="https://example.com/api/v1/client/subscribe?token=xxxx\nhttps://another-airport.com/sub?token=yyyy"
         style="width:100%;box-sizing:border-box;padding:10px;background:#16161e;border:1px solid #333;border-radius:8px;color:#e0e0e0;font-size:12px;font-family:monospace;resize:vertical"></textarea>
       <div style="display:flex;justify-content:flex-end;gap:8px;margin-top:16px">

package/src/watch/watchdog-server.js

@@ -831,7 +831,12 @@ async function handleSetErrorTrigger(params, body, res) {
   sendJSON(res, 200, { ok: true, config: cleaned });
 }
 
-/** 配置某 agent 的代理订阅（心跳下发 → daemon 热应用；空列表表示清空） */
+/**
+ * 配置某 agent 的代理订阅（心跳下发 → daemon 热应用；空列表表示清空）
+ * 允许同一订阅地址配置多行（每行一个独立实例，可各自使用不同节点）
+ * 上限 8 条: 与 discover.js RUNTIME_MAX_INSTANCES=8 对齐（第 9 条实例端口会超出
+ * 巡检枚举段 9097-9104，永远进不了 daemon 巡检列表）
+ */
 async function handleSetProxySettings(params, body, res) {
   const { userId, subscriptions } = body || {};
   if (!userId) {
@@ -842,16 +847,19 @@ async function handleSetProxySettings(params, body, res) {
     sendJSON(res, 400, { error: "subscriptions 须为数组" });
     return;
   }
-  // 归一化: 字符串或 {name,url}，去重去空
-  const seen = new Set();
+  // 归一化: 字符串或 {name,url}，去空去非法；不去重（同 URL 多行 = 多实例）
+  const MAX_SUBS = 8;
   const cleaned = [];
   for (const it of subscriptions) {
     const url = typeof it === "string" ? it.trim() : it && String(it.url || "").trim();
-    if (!url || !/^https?:\/\//.test(url) || seen.has(url)) continue;
-    seen.add(url);
+    if (!url || !/^https?:\/\//.test(url)) continue;
     const name = typeof it === "object" && it.name ? String(it.name).trim() : "";
     cleaned.push({ name, url });
   }
+  if (cleaned.length > MAX_SUBS) {
+    sendJSON(res, 400, { error: `最多 ${MAX_SUBS} 条（每条一个独立 mihomo 实例，超出部分无法巡检）` });
+    return;
+  }
   setProxySettingsStored(userId, { subscriptions: cleaned });
   const ts = new Date().toLocaleTimeString("zh-CN", { hour12: false });
   console.error(`[watchdog ${ts}] ${userId} 代理订阅配置已更新: ${cleaned.length} 条`);

package/src/watchdog/agent.js

@@ -113,7 +113,7 @@ const NETWORK_ERROR_PATTERNS = [
 ];
 const NETWORK_ERROR_RE = new RegExp(NETWORK_ERROR_PATTERNS.join("|"), "i");
 const ERROR_SCAN_INTERVAL_MS = 30_000; // 日志扫描间隔
-const SWITCH_SCAN_INTERVAL_MS = 15_000; // 代理切换感知检查间隔（daemon restartSeq 变化 → 重启全部命令）
+const SWITCH_SCAN_INTERVAL_MS = 15_000; // 代理切换感知检查间隔（daemon restartSeq 变化 → 重启对应通道命令）
 const ERROR_TRIGGER_COUNT = 10; // 连续错误阈值
 const ERROR_MIN_MS = 5 * 60 * 1000; // 最小持续时间（时间只做最小值判断）
 const ERROR_BREAK_MS = 120_000; // 两次错误间隔超过则视为连续中断，重置计数
@@ -145,6 +145,27 @@ function isWebserverMode(cmdDef) {
   return /--webserver(?=\s|=|$)/.test(cmdDef?.command || "");
 }
 
+/**
+ * 解析命令使用的代理端口（多实例通道路由）:
+ *   --proxy http://127.0.0.1:7898 / --proxy 127.0.0.1:7898 / --proxy=:7898 → 7898
+ *   无 --proxy（走系统代理 = 主控制端）→ null
+ * 用于: 错误触发 failover / 代理切换重启 时路由到出错命令实际使用的实例，
+ * 避免多实例下切错对象（用 7898 的命令报错却切了 7897 的节点）。
+ */
+function parseCmdProxyPort(cmdDef) {
+  const s = cmdDef?.command || "";
+  const m = s.match(/--proxy(?:=|\s+)(\S+)/);
+  if (!m) return null;
+  const pm = m[1].match(/:(\d{2,5})(?:\/|$)/);
+  return pm ? parseInt(pm[1], 10) : null;
+}
+
+/** 从 daemon 健康数据提取主控制端代理端口（meta.proxyUrl = http://127.0.0.1:7897） */
+function mainProxyPortOf(health) {
+  const m = String(health?.meta?.proxyUrl || "").match(/:(\d{2,5})\/?$/);
+  return m ? parseInt(m[1], 10) : null;
+}
+
 /** 自动发现 daemon.js 路径 */
 function findDaemonPath() {
   // 1. 内部打包路径优先（npm publish 后 src/clash/daemon.js，升级即最新）
@@ -459,35 +480,54 @@ export class WatchdogAgent {
     try {
       const health = getClashHealth();
       if (!health) return; // daemon 未就绪，暂不初始化基线
+      // 通道 → seq 映射: 主控制端（默认文件）与其代理端口通道是同一控制器双写，
+      // 用代理端口作 key 自动合并，避免同一次切换被当成两个通道
+      const mainPort = mainProxyPortOf(health);
       const seqMap = new Map();
-      seqMap.set("main", Number(health.restartSeq) || 0);
+      seqMap.set(mainPort || "main", Number(health.restartSeq) || 0);
       for (const ch of getClashHealthChannels()) {
-        seqMap.set(`ch${ch.port}`, Number(ch.restartSeq) || 0);
+        if (mainPort && ch.port === mainPort) continue; // 已并入主控制端 key
+        seqMap.set(ch.port, Number(ch.restartSeq) || 0);
       }
       if (this._restartSeqBaseline === null) {
         this._restartSeqBaseline = seqMap; // 首次读取建基线（watchdog 重启不误触发）
         return;
       }
-      let switched = false;
+      // 收集发生切换的通道（多实例各自独立切换，互不影响）
+      const switchedPorts = []; // 代理端口（数字）；主控制端无端口信息时为 null
+      let mainSwitched = false;
       for (const [key, seq] of seqMap) {
         if (seq > (this._restartSeqBaseline.get(key) || 0)) {
-          switched = true;
-          break;
+          if (key === "main") mainSwitched = true;
+          else {
+            switchedPorts.push(key);
+            if (key === mainPort) mainSwitched = true; // 主控制端端口通道切换
+          }
         }
       }
       this._restartSeqBaseline = seqMap;
-      if (!switched) return;
+      if (!switchedPorts.length && !mainSwitched) return;
+      const switchedDesc = switchedPorts.length
+        ? switchedPorts.join(",") + (mainSwitched ? ",主控制端" : "")
+        : "主控制端";
       if (!this._switchRestartEnabled) {
         console.error(
-          `[watchdog] 检测到代理切换但重启功能未启用（后台可开启），跳过重启`,
+          `[watchdog] 检测到代理切换(通道 ${switchedDesc})但重启功能未启用（后台可开启），跳过重启`,
         );
         return;
       }
       const reason = health.lastSwitch
         ? `代理切换(${health.lastSwitch})`
         : "代理切换";
-      console.error(`[watchdog] 检测到${reason}，强制重启全部命令...`);
-      await this.processManager.restartAll(reason);
+      // 只重启使用切换通道的命令（按 --proxy 匹配；无 --proxy 的命令走系统代理=主控制端）
+      // 避免多实例下误伤其它通道的命令
+      await this.processManager.restartMatching(
+        `代理切换(通道 ${switchedDesc}, ${reason})`,
+        (cmdDef) => {
+          const p = parseCmdProxyPort(cmdDef);
+          return p === null ? mainSwitched : switchedPorts.includes(p);
+        },
+      );
     } catch (e) {
       console.error(`[watchdog] 代理切换感知检查失败: ${e.message}`);
     }
@@ -548,18 +588,21 @@ export class WatchdogAgent {
     if (!this.running || !this._errorTriggerEnabled) return;
     const now = Date.now();
     const scanned = this.processManager.scanErrorLogs(NETWORK_ERROR_RE);
-    let failoverTriggered = false; // 本轮是否已触发全局切换
+    // 本轮已触发切换的通道（同通道只触发一次；不同通道互不阻塞——多实例各自出口独立）
+    const triggeredChannels = new Set();
     for (const { cmdId, cmdDef, newErrors } of scanned) {
       if (!isCollectorCommand(cmdDef)) continue;
       // webserver 模式：错误发生在远端出口，本地切节点无法解决，不计入错误触发统计
       if (isWebserverMode(cmdDef)) continue;
+      // 通道键: 命令实际使用的代理端口（多实例各切各的）；无 --proxy = 主控制端
+      const channelKey = parseCmdProxyPort(cmdDef) || "main";
       let st = this._errorStates.get(cmdId) || {
         consecutive: 0,
         firstErrorAt: 0,
         lastErrorAt: 0,
       };
-      if (failoverTriggered) {
-        // 本轮已有进程触发全局切换 → 该进程也从新计数开始（防同轮接力触发）
+      if (triggeredChannels.has(channelKey)) {
+        // 本轮该通道已触发切换 → 该进程也从新计数开始（防同轮接力触发）
         st = { consecutive: 0, firstErrorAt: 0, lastErrorAt: 0 };
       }
       const hadNew = newErrors.length > 0;
@@ -581,14 +624,13 @@ export class WatchdogAgent {
           now - st.firstErrorAt >= this._errorTriggerMinMs
         ) {
           console.error(
-            `[watchdog] ${cmdId} 连续 ${st.consecutive} 次错误（≥${this._errorTriggerCount}次，持续≥${this._errorTriggerMinMs / 60000}min），触发节点切换`,
+            `[watchdog] ${cmdId} 连续 ${st.consecutive} 次错误（≥${this._errorTriggerCount}次，持续≥${this._errorTriggerMinMs / 60000}min），触发节点切换 (通道 ${channelKey})`,
           );
-          this._triggerFailover(cmdId);
-          // 切换是全局的（所有子进程共用节点）：清空全部错误计数，
-          // 让新节点有干净的观察窗口，旧节点错误不再驱动后续切换；
-          // 触发者自身也重新计数（含本轮后续错误行，从 0 累计）。
+          this._triggerFailover(cmdId, parseCmdProxyPort(cmdDef));
+          // 切换作用于该命令实际使用的代理通道；同通道命令共用出口，
+          // 全部重新计数给新节点干净观察窗口（含触发者自身，从本轮后续错误重新累计）。
           this._errorStates.clear();
-          failoverTriggered = true;
+          triggeredChannels.add(channelKey);
           st = { consecutive: 0, firstErrorAt: 0, lastErrorAt: 0 };
         }
       }
@@ -616,31 +658,59 @@ export class WatchdogAgent {
     }
   }
 
-  /** 下发 failover 命令给 daemon（候选集切下一个可用节点） */
-  async _triggerFailover(cmdId) {
+  /**
+   * 下发 failover 命令给 daemon（候选集切下一个可用节点）
+   * @param {string} cmdId 触发源命令 id（日志用）
+   * @param {number|null} proxyPort 命令实际使用的代理端口（多实例路由；null=主控制端）
+   */
+  async _triggerFailover(cmdId, proxyPort = null) {
     try {
       const ipc = await import("../clash/ipc.js");
-      ipc.writeCommand({
-        action: "failover",
-        reason: `业务进程${cmdId ? ` ${cmdId}` : ""} 连续错误触发`,
-      });
-      console.error(`[watchdog] 已下发 failover 命令 (触发源: ${cmdId})`);
+      ipc.writeCommand(
+        {
+          action: "failover",
+          reason: `业务进程${cmdId ? ` ${cmdId}` : ""} 连续错误触发`,
+          ...(proxyPort ? { proxyPort } : {}),
+        },
+        proxyPort || 0,
+      );
+      console.error(
+        `[watchdog] 已下发 failover 命令 (触发源: ${cmdId}, 通道: ${proxyPort || "主控制端"})`,
+      );
     } catch (e) {
       console.error(`[watchdog] 下发 failover 失败: ${e.message}`);
     }
   }
 
-  /** 下发强切 failover（force: 无视 daemon 冷却期，直接轮换候选） */
+  /**
+   * 下发强切 failover（force: 无视 daemon 冷却期，直接轮换候选）
+   * 客户端异常告警无法归因到具体通道 → 对全部代理通道各发一条强切
+   * （默认通道=主控制端 + 其余实例通道；主控制端的代理端口通道与默认通道
+   *  是同一控制器双写，跳过避免同一次切换被切两次）
+   */
   async _forceFailover(reason) {
     try {
       const ipc = await import("../clash/ipc.js");
-      ipc.writeCommand({
-        action: "failover",
-        force: true,
-        reason: reason || "客户端异常强切",
-      });
+      const mainPort = mainProxyPortOf(getClashHealth());
+      const ports = [
+        0,
+        ...getClashHealthChannels()
+          .map((ch) => ch.port)
+          .filter((p) => p !== mainPort),
+      ];
+      for (const p of ports) {
+        ipc.writeCommand(
+          {
+            action: "failover",
+            force: true,
+            reason: reason || "客户端异常强切",
+            ...(p ? { proxyPort: p } : {}),
+          },
+          p,
+        );
+      }
       console.error(
-        `[watchdog] 已下发强切命令 (原因: ${reason || "客户端异常"})`,
+        `[watchdog] 已下发强切命令 (${ports.length} 个通道, 原因: ${reason || "客户端异常"})`,
       );
     } catch (e) {
       console.error(`[watchdog] 下发强切失败: ${e.message}`);

package/src/watchdog/process-manager.js

@@ -740,18 +740,29 @@ export class ProcessManager extends EventEmitter {
    * @returns {Promise<{restarted:number}>}
    */
   async restartAll(reason) {
+    return this.restartMatching(reason, () => true);
+  }
+
+  /**
+   * 按条件选择性强制重启（错峰停止 + 错峰启动，同 restartAll 语义）
+   * 多实例场景: 代理切换/故障切换只重启使用对应通道（--proxy 端口）的命令，
+   * 避免误伤其它通道的命令。
+   * @param {string} reason 重启原因（日志）
+   * @param {(cmdDef: object) => boolean} matchFn 命令匹配函数
+   */
+  async restartMatching(reason, matchFn) {
     const toRestart = [];
     for (const [, info] of this.processes) {
-      if (!info.stopped && info.child && info.cmdDef) {
+      if (!info.stopped && info.child && info.cmdDef && matchFn(info.cmdDef)) {
         toRestart.push(info.cmdDef);
       }
     }
     if (!toRestart.length) {
-      console.error(`[watchdog] ${reason}，无运行中的命令，跳过重启`);
+      console.error(`[watchdog] ${reason}，无匹配的运行中命令，跳过重启`);
       return { restarted: 0 };
     }
     console.error(
-      `[watchdog] ${reason}，强制重启全部命令 (${toRestart.length}个)...`,
+      `[watchdog] ${reason}，强制重启匹配命令 (${toRestart.length}个)...`,
     );
     // 错峰停止：第一个立即停，之后每个间隔 RESTART_STOP_STAGGER_MS（平滑释放资源，避免同时杀 N 个浏览器）
     for (let i = 0; i < toRestart.length; i++) {