tt-help-cli-ycl 1.4.140 → 1.4.144

package/src/watch/server.js

@@ -8,7 +8,7 @@ import { fileURLToPath } from "url";
 import { spawn } from "child_process";
 import { createStore } from "./data-store.js";
 import { getTagDb } from "./db-schema.js";
-import { DEFAULT_TARGET_LOCATIONS } from "../lib/target-locations.js";
+import { getTargetLocations } from "../lib/app-config.js";
 import { tryHandleWatchdogRoute } from "./watchdog-server.js";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -44,11 +44,17 @@ const SLOW_STATS_TTL = 300000; // 5 分钟
 const usersCache = new Map(); // key -> { result, time }
 const USERS_CACHE_TTL = 3000; // 3 秒
 
-// 目标国家占位符（jobs 表聚合需要 location_created IN (...)）
-const TARGET_PLACEHOLDERS = DEFAULT_TARGET_LOCATIONS.map(() => "?").join(", ");
-const TARGET_IN_SQL = DEFAULT_TARGET_LOCATIONS.length
-  ? `location_created IN (${TARGET_PLACEHOLDERS})`
-  : "1 = 0";
+// 目标国家占位符（jobs 表聚合需要 location_created IN (...)，运行时按 getTargetLocations() 动态生成）
+function targetPlaceholders() {
+  const locs = getTargetLocations();
+  return locs.map(() => "?").join(", ");
+}
+function targetInSql() {
+  const locs = getTargetLocations();
+  return locs.length
+    ? `location_created IN (${targetPlaceholders()})`
+    : "1 = 0";
+}
 
 // 统计分组定义：每组包含若干 SQL（分片执行）与一个聚合函数
 // sqls 项：{ key, sql, mode: 'one'|'all', params: 数组或返回数组的函数 }
@@ -80,8 +86,8 @@ const STAT_GROUPS = {
       {
         key: "jobsAgg",
         mode: "one",
-        params: DEFAULT_TARGET_LOCATIONS,
-        sql: `SELECT
+        params: () => getTargetLocations(),
+        sql: () => `SELECT
           SUM(jobsTotal) as jobsTotal,
           SUM(done) as done,
           SUM(error) as error,
@@ -94,7 +100,7 @@ const STAT_GROUPS = {
             SUM(CASE WHEN status = 'done' THEN 1 ELSE 0 END) as done,
             SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END) as error,
             SUM(CASE WHEN status = 'restricted' THEN 1 ELSE 0 END) as restricted,
-            SUM(CASE WHEN tt_seller = 1 AND verified = 0 AND ${TARGET_IN_SQL} THEN 1 ELSE 0 END) as targetUsers,
+            SUM(CASE WHEN tt_seller = 1 AND verified = 0 AND ${targetInSql()} THEN 1 ELSE 0 END) as targetUsers,
             SUM(CASE WHEN no_video = 1 THEN 1 ELSE 0 END) as noVideo
           FROM jobs
           UNION ALL
@@ -177,10 +183,10 @@ const STAT_GROUPS = {
       {
         key: "targetCountryStats",
         mode: "all",
-        params: DEFAULT_TARGET_LOCATIONS,
-        sql: `SELECT location_created as country, COUNT(*) as count
+        params: () => getTargetLocations(),
+        sql: () => `SELECT location_created as country, COUNT(*) as count
         FROM jobs
-        WHERE tt_seller = 1 AND verified = 0 AND ${TARGET_IN_SQL}
+        WHERE tt_seller = 1 AND verified = 0 AND ${targetInSql()}
         GROUP BY location_created
         ORDER BY count DESC`,
       },
@@ -284,9 +290,10 @@ function refreshGroupInShards(st, name) {
     if (idx < spec.sqls.length) {
       const s = spec.sqls[idx++];
       try {
+        const sql = typeof s.sql === "function" ? s.sql() : s.sql;
         const params =
           typeof s.params === "function" ? s.params() : s.params || [];
-        const r = st.rawQuery(s.sql, params);
+        const r = st.rawQuery(sql, params);
         if (r?.error) {
           console.error(`[stats] ${name}.${s.key} 查询失败: ${r.error}`);
           results[s.key] = null;
@@ -334,9 +341,10 @@ function computeGroupStats(st, name) {
     try {
       const results = {};
       for (const s of STAT_GROUPS[name].sqls) {
+        const sql = typeof s.sql === "function" ? s.sql() : s.sql;
         const params =
           typeof s.params === "function" ? s.params() : s.params || [];
-        const r = st.rawQuery(s.sql, params);
+        const r = st.rawQuery(sql, params);
         results[s.key] =
           s.mode === "all" ? r?.rows || [] : r?.rows?.[0] || null;
       }
@@ -641,7 +649,7 @@ export function startWatchServer(
         // 按国家维度判断：只为 new 标签不足的国家发现
         const countriesToDiscover = [];
         const { getTagsByStatus } = await import("./db-tags.js");
-        for (const country of DEFAULT_TARGET_LOCATIONS) {
+        for (const country of getTargetLocations()) {
           const newTags = getTagsByStatus("new", 100, 0, country, null, "llm");
           if (newTags.length < DISCOVER_PER_COUNTRY_THRESHOLD) {
             countriesToDiscover.push(country);
@@ -1137,7 +1145,7 @@ export function startWatchServer(
 
       if (req.method === "GET" && routePath === "/api/stats") {
         const stats = computeStatsIncremental(store);
-        stats.targetLocations = DEFAULT_TARGET_LOCATIONS;
+        stats.targetLocations = getTargetLocations();
         stats.clientLoginStatus = store.getClientLoginStatus();
         stats.activeClients = store.getActiveClients();
         sendJSON(res, 200, stats);
@@ -1494,7 +1502,7 @@ export function startWatchServer(
       }
 
       if (req.method === "GET" && routePath === "/api/target-users") {
-        const targetResult = store.getTargetUsers(DEFAULT_TARGET_LOCATIONS);
+        const targetResult = store.getTargetUsers(getTargetLocations());
         const targets = targetResult.users;
         if (req.headers["accept"]?.includes("text/csv")) {
           const columns = [
@@ -1549,19 +1557,16 @@ export function startWatchServer(
       ) {
         // 摘要模式：只返回各国统计数
         if (params.summary === "1") {
-          const result = store.getTargetUsersByCountry(
-            DEFAULT_TARGET_LOCATIONS,
-            { summaryOnly: true },
-          );
+          const result = store.getTargetUsersByCountry(getTargetLocations(), {
+            summaryOnly: true,
+          });
           sendJSON(res, 200, result);
           return;
         }
 
         // CSV 导出：全量数据
         if (req.headers["accept"]?.includes("text/csv")) {
-          const result = store.getTargetUsersByCountry(
-            DEFAULT_TARGET_LOCATIONS,
-          );
+          const result = store.getTargetUsersByCountry(getTargetLocations());
           const columns = [
             "uniqueId",
             "nickname",
@@ -1615,17 +1620,14 @@ export function startWatchServer(
 
         // 分页模式：按国家+搜索+分页查询用户
         if (params.limit) {
-          const result = store.getTargetUsersByCountry(
-            DEFAULT_TARGET_LOCATIONS,
-            {
-              country: params.country || undefined,
-              search: params.search || undefined,
-              limit: parseInt(params.limit, 10),
-              offset: parseInt(params.offset || "0", 10),
-              sort: params.sort || undefined,
-              sortOrder: params.sortOrder || "desc",
-            },
-          );
+          const result = store.getTargetUsersByCountry(getTargetLocations(), {
+            country: params.country || undefined,
+            search: params.search || undefined,
+            limit: parseInt(params.limit, 10),
+            offset: parseInt(params.offset || "0", 10),
+            sort: params.sort || undefined,
+            sortOrder: params.sortOrder || "desc",
+          });
           // 确保每个用户对象包含 topVideoPlayCount、topVideoHref 和 topVideoIsAd
           if (result.users && Array.isArray(result.users)) {
             result.users = result.users.map((u) => ({
@@ -1640,7 +1642,7 @@ export function startWatchServer(
         }
 
         // 默认：全量（兼容旧调用）
-        const result = store.getTargetUsersByCountry(DEFAULT_TARGET_LOCATIONS);
+        const result = store.getTargetUsersByCountry(getTargetLocations());
         // 确保每个用户对象包含 topVideoPlayCount、topVideoHref 和 topVideoIsAd
         if (result.countries && Array.isArray(result.countries)) {
           for (const country of result.countries) {
@@ -1662,9 +1664,8 @@ export function startWatchServer(
         req.method === "GET" &&
         routePath === "/api/target-users-other-countries"
       ) {
-        const result = store.getModifiedTargetUsersOutsideLocations(
-          DEFAULT_TARGET_LOCATIONS,
-        );
+        const result =
+          store.getModifiedTargetUsersOutsideLocations(getTargetLocations());
         sendJSON(res, 200, result);
         return;
       }
@@ -1842,6 +1843,49 @@ export function startWatchServer(
         return;
       }
 
+      // ====== 目标国家配置（通用 app-config 落盘） ======
+
+      // GET /api/settings/target-locations — 读取当前目标国家
+      if (
+        req.method === "GET" &&
+        routePath === "/api/settings/target-locations"
+      ) {
+        try {
+          const { getTargetLocations } = await import("../lib/app-config.js");
+          sendJSON(res, 200, { locations: getTargetLocations() });
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
+      // POST /api/settings/target-locations — 保存目标国家（body: { locations: ["CZ","GR",...] }）
+      if (
+        req.method === "POST" &&
+        routePath === "/api/settings/target-locations"
+      ) {
+        try {
+          const body = await readBody(req);
+          const { setTargetLocations } = await import("../lib/app-config.js");
+          const saved = setTargetLocations(body.locations);
+          sendJSON(res, 200, { locations: saved });
+        } catch (e) {
+          sendJSON(res, 400, { error: e.message });
+        }
+        return;
+      }
+
+      // GET /api/settings/config — 读取整份通用配置（便于后续扩展其他配置）
+      if (req.method === "GET" && routePath === "/api/settings/config") {
+        try {
+          const { getConfig } = await import("../lib/app-config.js");
+          sendJSON(res, 200, { config: getConfig() });
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
       // GET /api/llm-test — 直接测试 LLM API 连通性
       if (req.method === "GET" && routePath === "/api/llm-test") {
         try {
@@ -1915,6 +1959,7 @@ export function startWatchServer(
             body.username || "",
             body.stage || "",
             body.errorStack || "",
+            body.hostname || req.headers["x-client-hostname"] || "",
           );
           sendJSON(res, 200, { ok: true });
         } else {
@@ -1938,7 +1983,7 @@ export function startWatchServer(
             targetLocation: params.targetLocation,
             limit: params.limit,
             offset: params.offset,
-            targetLocations: DEFAULT_TARGET_LOCATIONS,
+            targetLocations: getTargetLocations(),
           });
           usersCache.set(cacheKey, { result, time: Date.now() });
         }

package/src/watch/watchdog-server.js

@@ -258,6 +258,46 @@ function getAllErrorTriggers() {
   return cfg.errorTriggers || {};
 }
 
+// ── 代理切换重启配置管理（per agent，默认不启用：切换后不重启，后端下发开启才重启） ──
+
+function getSwitchRestartStored(userId) {
+  if (!userId) return null;
+  const cfg = loadConfig();
+  return (cfg.switchRestarts && cfg.switchRestarts[userId]) || null;
+}
+
+function setSwitchRestartStored(userId, config) {
+  const cfg = loadConfig();
+  if (!cfg.switchRestarts) cfg.switchRestarts = {};
+  cfg.switchRestarts[userId] = config;
+  saveConfig(cfg);
+}
+
+function getAllSwitchRestarts() {
+  const cfg = loadConfig();
+  return cfg.switchRestarts || {};
+}
+
+// ── 自动升级开关配置管理（per agent，默认开启：未配置或 enabled=true 均开启，后端显式关闭才停用） ──
+
+function getAutoUpgradeStored(userId) {
+  if (!userId) return null;
+  const cfg = loadConfig();
+  return (cfg.autoUpgrades && cfg.autoUpgrades[userId]) || null;
+}
+
+function setAutoUpgradeStored(userId, config) {
+  const cfg = loadConfig();
+  if (!cfg.autoUpgrades) cfg.autoUpgrades = {};
+  cfg.autoUpgrades[userId] = config;
+  saveConfig(cfg);
+}
+
+function getAllAutoUpgrades() {
+  const cfg = loadConfig();
+  return cfg.autoUpgrades || {};
+}
+
 // ── 登录端口检测配置管理（per agent，后端配置要检查的 CDP 端口列表） ──
 
 function getLoginPortsStored(userId) {
@@ -438,6 +478,8 @@ async function handleHeartbeat(params, body, res) {
     logRequests: pendingLogs.length > 0 ? pendingLogs : undefined,
     clientConfig: getClientConfigStored(userId),
     errorTrigger: getErrorTriggerStored(userId),
+    switchRestart: getSwitchRestartStored(userId),
+    autoUpgrade: getAutoUpgradeStored(userId),
     loginPorts: getLoginPortsStored(userId),
     serverTime: Date.now(),
   });
@@ -452,6 +494,8 @@ async function handleGetClients(params, body, res) {
     clashCountries: getAllClientCountries(),
     supportedCountries: SUPPORTED_COUNTRIES,
     errorTriggers: getAllErrorTriggers(),
+    switchRestarts: getAllSwitchRestarts(),
+    autoUpgrades: getAllAutoUpgrades(),
     loginPorts: getAllLoginPorts(),
     configPath: WATCHDOG_CONFIG_PATH,
   });
@@ -605,6 +649,8 @@ async function handleDeleteClient(params, body, res) {
   if (cfg.clientConfigs) delete cfg.clientConfigs[userId];
   if (cfg.clashCountries) delete cfg.clashCountries[userId];
   if (cfg.errorTriggers) delete cfg.errorTriggers[userId];
+  if (cfg.switchRestarts) delete cfg.switchRestarts[userId];
+  if (cfg.autoUpgrades) delete cfg.autoUpgrades[userId];
   if (cfg.loginPorts) delete cfg.loginPorts[userId];
   saveConfig(cfg);
   lastSentCountries.delete(userId);
@@ -725,6 +771,52 @@ async function handleSetErrorTrigger(params, body, res) {
   sendJSON(res, 200, { ok: true, config: cleaned });
 }
 
+/** 配置某 agent 的代理切换重启（代理切换后强制重启全部命令；默认不启用） */
+async function handleSetSwitchRestart(params, body, res) {
+  const { userId, config } = body || {};
+  if (!userId) {
+    sendJSON(res, 400, { error: "缺少 userId" });
+    return;
+  }
+  if (!config || typeof config !== "object") {
+    sendJSON(res, 400, { error: "缺少 config 对象" });
+    return;
+  }
+  const cleaned = {
+    enabled: !!config.enabled,
+    updatedAt: new Date().toISOString(),
+  };
+  setSwitchRestartStored(userId, cleaned);
+  const ts = new Date().toLocaleTimeString("zh-CN", { hour12: false });
+  console.error(
+    `[watchdog ${ts}] ${userId} 代理切换重启配置已更新: ${JSON.stringify(cleaned)}`,
+  );
+  sendJSON(res, 200, { ok: true, config: cleaned });
+}
+
+/** 配置某 agent 的自动升级开关（默认开启；后端显式关闭才停用自动升级检测） */
+async function handleSetAutoUpgrade(params, body, res) {
+  const { userId, config } = body || {};
+  if (!userId) {
+    sendJSON(res, 400, { error: "缺少 userId" });
+    return;
+  }
+  if (!config || typeof config !== "object") {
+    sendJSON(res, 400, { error: "缺少 config 对象" });
+    return;
+  }
+  const cleaned = {
+    enabled: !!config.enabled,
+    updatedAt: new Date().toISOString(),
+  };
+  setAutoUpgradeStored(userId, cleaned);
+  const ts = new Date().toLocaleTimeString("zh-CN", { hour12: false });
+  console.error(
+    `[watchdog ${ts}] ${userId} 自动升级配置已更新: ${JSON.stringify(cleaned)}`,
+  );
+  sendJSON(res, 200, { ok: true, config: cleaned });
+}
+
 /** 配置某 agent 要检测登录状态的 CDP 端口列表（逗号分隔或数组） */
 async function handleSetLoginPorts(params, body, res) {
   const { userId, ports } = body || {};
@@ -833,6 +925,14 @@ export async function tryHandleWatchdogRoute(
     await handleSetErrorTrigger(params, body, res);
     return true;
   }
+  if (method === "POST" && routePath === "/api/watchdog/set-switch-restart") {
+    await handleSetSwitchRestart(params, body, res);
+    return true;
+  }
+  if (method === "POST" && routePath === "/api/watchdog/set-auto-upgrade") {
+    await handleSetAutoUpgrade(params, body, res);
+    return true;
+  }
   if (method === "POST" && routePath === "/api/watchdog/login-ports") {
     await handleSetLoginPorts(params, body, res);
     return true;

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 }) => {