tt-help-cli-ycl 1.4.140 → 1.4.142

package/src/watchdog/agent.js

@@ -24,9 +24,10 @@ import {
 import { writeFileSync, existsSync, readFileSync } from "fs";
 import { spawn } from "child_process";
 import { join, dirname } from "path";
-import { homedir, tmpdir } from "os";
+import { homedir, tmpdir, hostname as osHostname } from "os";
 import { fileURLToPath } from "url";
 import { pushSelfLog, getSelfLogs } from "./self-log-buffer.js";
+import { ClientErrorMonitor } from "./client-error-monitor.js";
 
 // ── 看门狗自身日志入环（供后台页面按需拉取，经 report-logs 回传落盘） ──
 // 包装 console.error：本进程所有 [watchdog]/[llm-analyzer]/[upgrade] 等日志
@@ -111,6 +112,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 ERROR_TRIGGER_COUNT = 10; // 连续错误阈值
 const ERROR_MIN_MS = 5 * 60 * 1000; // 最小持续时间（时间只做最小值判断）
 const ERROR_BREAK_MS = 120_000; // 两次错误间隔超过则视为连续中断，重置计数
@@ -262,6 +264,7 @@ export class WatchdogAgent {
     this.thresholdTimer = null;
     this.llmAnalyzerTimer = null;
     this.processManager = new ProcessManager();
+    this.clientErrorMonitor = null; // 客户端异常监控（watch 异常列表 → 本机命中强切 + 清理）
     this.consecutiveFailures = 0;
     this.maxFailures = 10;
     this.upgradeChecker = null;
@@ -287,6 +290,11 @@ export class WatchdogAgent {
       this._errorStates.delete(cmdId);
     });
     this._errorTriggerTimer = null;
+    this._switchCheckTimer = null; // 代理切换感知定时器
+    this._restartSeqBaseline = null; // 已消费的切换序号基线 Map<通道,seq>（首次读取初始化）
+    this._switchRestartEnabled = false; // 代理切换重启默认不启用（后端下发开启才生效）
+    this._switchRestartConfigKey = null; // 上次配置指纹（幂等打印用）
+    this._autoUpgradeEnabled = true; // 自动升级默认开启（后端下发关闭才停用）
     this._errorTriggerEnabled = false; // 默认不启用（后端下发开启才生效）
     this._errorTriggerCount = ERROR_TRIGGER_COUNT;
     this._errorTriggerMinMs = ERROR_MIN_MS;
@@ -345,6 +353,11 @@ export class WatchdogAgent {
       this._checkProcessErrors();
     }, ERROR_SCAN_INTERVAL_MS);
 
+    // 代理切换感知：daemon 每次实际切换 restartSeq+1，变化即强制重启全部命令
+    this._switchCheckTimer = setInterval(() => {
+      this._checkProxySwitch();
+    }, SWITCH_SCAN_INTERVAL_MS);
+
     // 登录检测调度：每 60s 检查一次是否到点（首次 60s 后检测，之后每 loginCheckIntervalMs）
     this.loginCheckTimer = setInterval(() => {
       this._maybeRunLoginCheck();
@@ -358,6 +371,9 @@ export class WatchdogAgent {
 
     // 自动升级检测（仅全局安装模式）
     this._startUpgradeChecker();
+
+    // 客户端异常监控（watch 服务端异常列表 → 本机命中强切 + 清理）
+    this._startClientErrorMonitor();
   }
 
   /**
@@ -381,6 +397,10 @@ export class WatchdogAgent {
       clearInterval(this._errorTriggerTimer);
       this._errorTriggerTimer = null;
     }
+    if (this._switchCheckTimer) {
+      clearInterval(this._switchCheckTimer);
+      this._switchCheckTimer = null;
+    }
     if (this.loginCheckTimer) {
       clearInterval(this.loginCheckTimer);
       this.loginCheckTimer = null;
@@ -393,6 +413,10 @@ export class WatchdogAgent {
       this.upgradeChecker.stop();
       this.upgradeChecker = null;
     }
+    if (this.clientErrorMonitor) {
+      this.clientErrorMonitor.stop();
+      this.clientErrorMonitor = null;
+    }
     // 停止 clash daemon（标记主动关闭，exit 时不再自动重启）
     this._daemonStopping = true;
     if (this._daemonRestartTimer) {
@@ -404,6 +428,80 @@ export class WatchdogAgent {
     console.error("[watchdog] 看门狗已停止");
   }
 
+  /**
+   * 代理切换感知：读 daemon health 的 restartSeq，任一通道变大即发生过切换，
+   * 强制重启全部被监控命令。默认不启用（后端开关开启才重启）；
+   * 基线始终跟随 seq（无论开关状态）：开启后只响应"新切换"，不补触发历史切换。
+   * 变小 = daemon 重启序号归零，只更新基线不触发（防 watchdog/daemon 重启误伤）。
+   */
+  async _checkProxySwitch() {
+    try {
+      const health = getClashHealth();
+      if (!health) return; // daemon 未就绪，暂不初始化基线
+      const seqMap = new Map();
+      seqMap.set("main", Number(health.restartSeq) || 0);
+      for (const ch of getClashHealthChannels()) {
+        seqMap.set(`ch${ch.port}`, Number(ch.restartSeq) || 0);
+      }
+      if (this._restartSeqBaseline === null) {
+        this._restartSeqBaseline = seqMap; // 首次读取建基线（watchdog 重启不误触发）
+        return;
+      }
+      let switched = false;
+      for (const [key, seq] of seqMap) {
+        if (seq > (this._restartSeqBaseline.get(key) || 0)) {
+          switched = true;
+          break;
+        }
+      }
+      this._restartSeqBaseline = seqMap;
+      if (!switched) return;
+      if (!this._switchRestartEnabled) {
+        console.error(
+          `[watchdog] 检测到代理切换但重启功能未启用（后台可开启），跳过重启`,
+        );
+        return;
+      }
+      const reason = health.lastSwitch
+        ? `代理切换(${health.lastSwitch})`
+        : "代理切换";
+      console.error(`[watchdog] 检测到${reason}，强制重启全部命令...`);
+      await this.processManager.restartAll(reason);
+    } catch (e) {
+      console.error(`[watchdog] 代理切换感知检查失败: ${e.message}`);
+    }
+  }
+
+  /** 应用服务端下发的代理切换重启配置（默认不启用，后端下发开启才生效） */
+  _applySwitchRestartConfig(cfg) {
+    this._switchRestartEnabled = !!cfg?.enabled;
+    const key = `${this._switchRestartEnabled}`;
+    if (key === this._switchRestartConfigKey) return;
+    this._switchRestartConfigKey = key;
+    console.error(
+      `[watchdog] 代理切换重启: ${this._switchRestartEnabled ? "已启用" : "已禁用"}（切换后${this._switchRestartEnabled ? "" : "不"}强制重启命令）`,
+    );
+  }
+
+  /**
+   * 应用服务端下发的自动升级开关
+   * 未配置（null/undefined）= 默认开启；后端显式 {enabled:false} 才停用升级检测器
+   */
+  _applyAutoUpgradeConfig(cfg) {
+    const enabled = cfg ? !!cfg.enabled : true;
+    if (enabled === this._autoUpgradeEnabled) return; // 幂等，避免每次心跳重复启停
+    this._autoUpgradeEnabled = enabled;
+    console.error(
+      `[watchdog] 自动升级: ${enabled ? "已开启" : "已关闭"}${cfg ? "" : "（未配置，默认开启）"}`,
+    );
+    if (enabled) {
+      if (!this.upgradeChecker) this._startUpgradeChecker();
+    } else if (this.upgradeChecker) {
+      this.upgradeChecker.stop();
+      this.upgradeChecker = null;
+    }
+  }
+
   /** 应用服务端下发的错误触发切换配置（控制启用与参数，默认不启用） */
   _applyErrorTriggerConfig(cfg) {
     this._errorTriggerEnabled = !!cfg?.enabled;
@@ -511,6 +609,55 @@ export class WatchdogAgent {
     }
   }
 
+  /** 下发强切 failover（force: 无视 daemon 冷却期，直接轮换候选） */
+  async _forceFailover(reason) {
+    try {
+      const ipc = await import("../clash/ipc.js");
+      ipc.writeCommand({
+        action: "failover",
+        force: true,
+        reason: reason || "客户端异常强切",
+      });
+      console.error(
+        `[watchdog] 已下发强切命令 (原因: ${reason || "客户端异常"})`,
+      );
+    } catch (e) {
+      console.error(`[watchdog] 下发强切失败: ${e.message}`);
+    }
+  }
+
+  /**
+   * 启动客户端异常监控：定时拉取 watch 服务端异常列表，
+   * 命中本机条目（reportCount > 8 且最近 2 分钟内）→ 强切代理 + 删除全部本机条目。
+   */
+  _startClientErrorMonitor() {
+    const cfg = getClientConfig();
+    const server = cfg.server || "";
+    if (!server) {
+      console.error(
+        "[watchdog] 未配置 watch 服务端地址 (server)，客户端异常监控跳过",
+      );
+      return;
+    }
+    this.clientErrorMonitor = new ClientErrorMonitor({
+      serverUrl: server,
+      hostname: osHostname(),
+      intervalMs: 60_000,
+      onAlert: async (mine) => {
+        const ids = mine.map((e) => e.userId).join(",");
+        console.error(
+          `[watchdog] 客户端异常监控命中 ${mine.length} 条本机异常 (${ids})，强制切换代理并清理`,
+        );
+        await this._forceFailover("client-errors");
+        const removed = await this.clientErrorMonitor.removeErrors(mine);
+        console.error(
+          `[watchdog] 已清理本机异常条目 ${removed}/${mine.length}`,
+        );
+      },
+    });
+    this.clientErrorMonitor.start();
+  }
+
   /** 构建心跳请求体 */
   _buildHeartbeatBody() {
     const sys = getSystemInfo();
@@ -609,6 +756,14 @@ export class WatchdogAgent {
       if (data.errorTrigger) {
         this._applyErrorTriggerConfig(data.errorTrigger);
       }
+      // 服务端下发的代理切换重启配置（默认不启用，后端下发开启才生效）
+      if (data.switchRestart) {
+        this._applySwitchRestartConfig(data.switchRestart);
+      }
+      // 服务端下发的自动升级开关（未配置默认开启；后端显式关闭才停用）
+      if (data.autoUpgrade !== undefined) {
+        this._applyAutoUpgradeConfig(data.autoUpgrade);
+      }
       // 服务端下发的登录检测端口列表
       if (Array.isArray(data.loginPorts)) {
         const key = data.loginPorts.join(",");
@@ -873,6 +1028,7 @@ export class WatchdogAgent {
    */
   _startUpgradeChecker() {
     if (!isGlobalInstall()) return;
+    if (!this._autoUpgradeEnabled) return;
 
     this.upgradeChecker = startUpgradeChecker({
       onUpdateAvailable: async ({ current, latest }) => {

package/src/watchdog/client-error-monitor.js

@@ -0,0 +1,131 @@
+/**
+ * 客户端异常监控模块 — 看门狗侧
+ *
+ * 职责：
+ *   1. 定时拉取 watch 服务端 /api/client-errors
+ *   2. 按 hostname 过滤出本机条目（异常条目由业务进程上报时携带 hostname）
+ *   3. 逐条过独立检测函数，命中 → onAlert(本机全部条目, 命中条目)
+ *   4. 提供 removeErrors 删除接口（处理完成后的清理）
+ *
+ * 检测函数第一版：reportCount > 8 且最近一次上报在 2 分钟内。
+ */
+
+import os from "os";
+
+/** 检测阈值：累计上报次数 > 8 */
+export const DETECT_REPORT_COUNT_THRESHOLD = 8;
+/** 检测窗口：最近一次上报距今 < 2 分钟 */
+export const DETECT_FRESH_MS = 2 * 60 * 1000;
+
+/**
+ * 独立检测函数（第一版）
+ * @param {object} err - /api/client-errors 返回的单条异常
+ * @param {number} [now] - 当前时间戳（测试注入用）
+ * @returns {boolean}
+ */
+export function detectClientError(err, now = Date.now()) {
+  if (!err || typeof err.reportCount !== "number") return false;
+  const fresh = now - err.timestamp < DETECT_FRESH_MS;
+  return err.reportCount > DETECT_REPORT_COUNT_THRESHOLD && fresh;
+}
+
+/**
+ * 客户端异常监控器
+ */
+export class ClientErrorMonitor {
+  /**
+   * @param {object} opts
+   * @param {string} opts.serverUrl - watch 服务端地址（~/.tt-help.json 的 server）
+   * @param {string} [opts.hostname] - 本机 hostname（默认 os.hostname()）
+   * @param {number} [opts.intervalMs] - 拉取周期，默认 60s
+   * @param {(err: object, now: number) => boolean} [opts.detect] - 检测函数，默认 detectClientError
+   * @param {(mine: Array, hit: Array) => Promise|void} [opts.onAlert] - 命中回调
+   */
+  constructor({ serverUrl, hostname, intervalMs = 60_000, detect, onAlert }) {
+    this.serverUrl = serverUrl ? String(serverUrl).replace(/\/+$/, "") : "";
+    this.hostname = hostname || os.hostname();
+    this.intervalMs = intervalMs;
+    this.detect = detect || detectClientError;
+    this.onAlert = onAlert || null;
+    this.timer = null;
+    this.running = false;
+    this._polling = false; // 防重入
+  }
+
+  /** 启动轮询（立即拉一次，之后按周期） */
+  start() {
+    if (this.running || !this.serverUrl) return;
+    this.running = true;
+    this.timer = setInterval(
+      () => this._poll().catch(() => {}),
+      this.intervalMs,
+    );
+    this._poll().catch(() => {});
+  }
+
+  stop() {
+    this.running = false;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  /**
+   * 拉取一次并评估
+   * @returns {Promise<Array|null>} 本机命中的条目；无可评估内容时返回 null
+   */
+  async _poll() {
+    if (this._polling) return null;
+    this._polling = true;
+    try {
+      const resp = await fetch(`${this.serverUrl}/api/client-errors`, {
+        signal: AbortSignal.timeout(10000),
+      });
+      if (!resp.ok) return null;
+      const data = await resp.json();
+      const clients = Array.isArray(data.clients) ? data.clients : [];
+      // hostname 为空的旧条目（升级前上报）不参与本机关联
+      const mine = clients.filter(
+        (c) => c.hostname && c.hostname === this.hostname,
+      );
+      if (mine.length === 0) return null;
+      const now = Date.now();
+      const hit = mine.filter((c) => this.detect(c, now));
+      if (hit.length > 0 && this.onAlert) {
+        try {
+          await this.onAlert(mine, hit);
+        } catch {
+          /* 回调异常不中断轮询 */
+        }
+      }
+      return hit;
+    } catch {
+      return null; // 网络/解析失败下轮重试
+    } finally {
+      this._polling = false;
+    }
+  }
+
+  /**
+   * 删除指定异常条目（处理完成后的清理）
+   * @param {Array<{userId:string}>} errors
+   * @returns {Promise<number>} 成功删除条数
+   */
+  async removeErrors(errors) {
+    let removed = 0;
+    for (const e of errors || []) {
+      if (!e || !e.userId) continue;
+      try {
+        const resp = await fetch(
+          `${this.serverUrl}/api/client-error/${encodeURIComponent(e.userId)}`,
+          { method: "DELETE", signal: AbortSignal.timeout(10000) },
+        );
+        if (resp.ok) removed++;
+      } catch {
+        /* 单条失败不影响其余 */
+      }
+    }
+    return removed;
+  }
+}

package/src/watchdog/process-manager.js

@@ -23,6 +23,7 @@ const MAX_RESTART = 3;
 const MAX_LOG_LINES = 500; // 每个进程最多保留的日志行数
 const IS_WIN = process.platform === "win32";
 const SPAWN_STAGGER_MS = 30000; // 批量启动时每个进程间隔 30 秒，避免抢网络
+const STOP_STAGGER_MS = 10000; // 强制重启时每个命令停止间隔 10 秒（杀 Edge/进程树会瞬时占资源，错峰释放）
 const STALE_LOG_TIMEOUT_MS = 15 * 60 * 1000; // 15 分钟无日志输出视为假死
 
 // === 控制台日志格式化（仅显示层增强，不影响任何功能链路） ===
@@ -718,10 +719,58 @@ export class ProcessManager extends EventEmitter {
     }
   }
 
+  /**
+   * 强制重启所有运行中的命令（先停全部，再错峰逐个重启）
+   * 用途：代理切换后强制所有业务命令重建连接、走新出口节点
+   * @param {string} [reason] - 重启原因（日志用）
+   * @returns {Promise<{restarted:number}>}
+   */
+  async restartAll(reason) {
+    const toRestart = [];
+    for (const [, info] of this.processes) {
+      if (!info.stopped && info.child && info.cmdDef) {
+        toRestart.push(info.cmdDef);
+      }
+    }
+    if (!toRestart.length) {
+      console.error(`[watchdog] ${reason}，无运行中的命令，跳过重启`);
+      return { restarted: 0 };
+    }
+    console.error(
+      `[watchdog] ${reason}，强制重启全部命令 (${toRestart.length}个)...`,
+    );
+    // 错峰停止：第一个立即停，之后每个间隔 STOP_STAGGER_MS（平滑释放资源，避免同时杀 N 个浏览器）
+    for (let i = 0; i < toRestart.length; i++) {
+      if (i > 0) await new Promise((r) => setTimeout(r, STOP_STAGGER_MS));
+      if (this.shutdown) {
+        console.error("[watchdog] 看门狗已停止，中止停止命令");
+        break;
+      }
+      this.stopCommand(toRestart[i].id);
+      console.error(
+        `[watchdog] 命令 ${toRestart[i].id} 已停止 (${i + 1}/${toRestart.length})`,
+      );
+    }
+    // 错峰逐个重启：第一个立即起，之后每个间隔 SPAWN_STAGGER_MS
+    for (let i = 0; i < toRestart.length; i++) {
+      if (i > 0) await new Promise((r) => setTimeout(r, SPAWN_STAGGER_MS));
+      if (this.shutdown) {
+        console.error("[watchdog] 看门狗已停止，中止重启命令");
+        break;
+      }
+      this.startCommand(toRestart[i]);
+      console.error(
+        `[watchdog] 命令 ${toRestart[i].id} 已重启 (${i + 1}/${toRestart.length})`,
+      );
+    }
+    return { restarted: toRestart.length };
+  }
+
   /**
    * 停止所有进程
    */
   stopAll() {
+    this.shutdown = true;
     console.error("[watchdog] 正在停止所有子进程...");
     for (const [cmdId] of this.processes) {
       this.stopCommand(cmdId);

package/src/webserver/server.mjs

@@ -741,6 +741,7 @@ async function notifyCaptchaToWatch(url, maxRetries = 3) {
             "TikTok Shop captcha detected, browser opened - manual intervention required",
           stage: "product_info",
           errorStack: url,
+          hostname: os.hostname(),
         }),
       });
       console.error("[webserver] Captcha alert sent to watch server");