tt-help-cli-ycl 1.4.172 → 1.4.176

package/src/watch/subscription-center.js

@@ -45,6 +45,7 @@ const HISTORY_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000; // 快照历史保留 30
 const RESETS_MAX = 20; // 重置事件最多保留条数
 const NODE_REPORT_STALE_MS = 26 * 60 * 60 * 1000; // 节点代报数据超过 26h 视为陈旧
 const SUBS_MAX = 64; // 订阅池容量上限
+const WEIGHT_MAX = 10; // 自动分配权重上限（1=普通份额，越大占比越高；下限恒为 1，无 0 值语义）
 const UA = "clash.meta/1.19.31"; // 机场按 UA 发货：浏览器 UA 拿到 HTML 页，Clash UA 才带头
 const SAVE_DEBOUNCE_MS = 3 * 1000;
 
@@ -423,7 +424,14 @@ function cleanText(v, max) {
   return typeof v === "string" ? v.trim().slice(0, max || 120) : "";
 }
 
-export function addSubscription({ name, url, note } = {}) {
+/** 权重归一化：非法/缺省 → 1；钳位 1..WEIGHT_MAX（只入整数） */
+function normalizeWeight(v) {
+  const n = parseInt(v, 10);
+  if (!Number.isFinite(n)) return 1;
+  return Math.max(1, Math.min(WEIGHT_MAX, n));
+}
+
+export function addSubscription({ name, url, note, weight } = {}) {
   load();
   url = cleanText(url, 2048);
   if (!url || !/^https?:\/\//.test(url))
@@ -438,6 +446,7 @@ export function addSubscription({ name, url, note } = {}) {
     name: cleanText(name, 64) || `订阅-${_subs.length + 1}`,
     url,
     note: cleanText(note, 200),
+    weight: normalizeWeight(weight),
     enabled: true,
     addedAt: now,
     updatedAt: now,
@@ -452,7 +461,7 @@ export function addSubscription({ name, url, note } = {}) {
   return { ok: true, entry };
 }
 
-export function updateSubscription({ id, name, url, note, enabled } = {}) {
+export function updateSubscription({ id, name, url, note, enabled, weight } = {}) {
   load();
   const entry = _subs.find((s) => s.id === id);
   if (!entry) return { ok: false, error: "订阅不存在" };
@@ -470,6 +479,12 @@ export function updateSubscription({ id, name, url, note, enabled } = {}) {
   if (name !== undefined) entry.name = cleanText(name, 64) || entry.name;
   if (note !== undefined) entry.note = cleanText(note, 200);
   if (enabled !== undefined) entry.enabled = !!enabled;
+  if (weight !== undefined) {
+    const w = normalizeWeight(weight);
+    if (w !== (entry.weight || 1))
+      console.error(`[订阅中心] ⚖ 「${entry.name}」分配权重 ${entry.weight || 1} → ${w}`);
+    entry.weight = w;
+  }
   entry.updatedAt = Date.now();
   saveNow();
   console.error(
@@ -532,6 +547,7 @@ export function getSubscriptionView() {
       id: e.id,
       name: e.name,
       note: e.note || "",
+      weight: e.weight || 1,
       enabled: e.enabled !== false,
       addedAt: e.addedAt || 0,
       // URL 仅控制页面可见，含 token 不进任何服务端日志

package/src/watch/watchdog-server.js

@@ -30,6 +30,7 @@ import {
   probeSubscription,
 } from "./subscription-center.js";
 import { reconcileAutoAlloc, ALLOC_MAX_INSTANCES } from "./subscription-allocator.js";
+import { heartbeatLoginPool, getLoginPoolView, addAccount, updateAccount, deleteAccount, assignAccount, releaseAccount } from "./login-pool.js";
 
 const homeDir = homedir() || process.env.HOME || process.env.USERPROFILE || "";
 const WATCHDOG_CONFIG_PATH = join(homeDir, ".tt-help-watchdog.json");
@@ -58,6 +59,8 @@ const clashCmdQueue = new Map();
 // 登录检测手动重检队列：clientId → true（后台页面点「重检」下发，随心跳取走即清空，一次性）
 const loginRecheckQueue = new Map();
 
+// 登录池命令队列在 login-pool.js 内部管理（userId → [applyLogin/clearLogin]，取走即清空）
+
 // 国家过滤配置幂等下发记录：userId → JSON.stringify(countries)
 // 仅当配置变化时才入队，避免每次心跳都触发 daemon 刷新候选集
 const lastSentCountries = new Map();
@@ -558,6 +561,14 @@ async function handleHeartbeat(params, body, res) {
   const loginRecheck = loginRecheckQueue.get(clientId) || false;
   if (loginRecheck) loginRecheckQueue.delete(clientId);
 
+  // 登录池：续租 + 健康采集 + 取走 applyLogin/clearLogin 命令（一次性）
+  let loginPoolCmds;
+  try {
+    loginPoolCmds = heartbeatLoginPool(userId, body);
+  } catch (e) {
+    console.error(`[watchdog] 登录池心跳处理异常: ${e.message}`);
+  }
+
   const ts = new Date().toLocaleTimeString("zh-CN", { hour12: false });
   console.error(
     `[watchdog ${ts}] 心跳: ${clientId} (${body.hostname || "?"}, user=${userId || "?"}) ${body.processes?.length || 0}进程, 返回${commands.length}条命令${clashCommands.length ? ", " + clashCommands.length + "条Clash命令" : ""}`,
@@ -575,6 +586,7 @@ async function handleHeartbeat(params, body, res) {
     autoUpgrade: getAutoUpgradeStored(userId),
     loginPorts: getLoginPortsStored(userId),
     loginRecheck: loginRecheck || undefined,
+    loginPool: loginPoolCmds,
     serverTime: Date.now(),
   });
 }
@@ -595,6 +607,8 @@ async function handleGetClients(params, body, res) {
     configPath: WATCHDOG_CONFIG_PATH,
     // 订阅中心视图（探测/代报快照 + 状态推导 + 引用关系；独立文件，读多写少）
     subscriptions: getSubscriptionViewSafe(),
+    // 登录池视图（脱敏，永不含 cookies 明文；独立文件）
+    loginPool: getLoginPoolViewSafe(),
   });
 }
 
@@ -607,6 +621,15 @@ function getSubscriptionViewSafe() {
   }
 }
 
+function getLoginPoolViewSafe() {
+  try {
+    return getLoginPoolView();
+  } catch (e) {
+    console.error(`[watchdog] 登录池视图构建失败: ${e.message}`);
+    return { accounts: [], total: 0 };
+  }
+}
+
 // ── 订阅中心 API（Phase 1: 池子 CRUD + 主动探测 + 只读引用展示，不改任何节点行为） ──
 
 async function handleSubscriptionsList(params, body, res) {
@@ -1118,6 +1141,72 @@ async function handleRecheckLogin(params, body, res) {
   sendJSON(res, 200, { ok: true, message: "已下发重检，客户端下次心跳时执行" });
 }
 
+// ── 登录池 API（脱敏视图；cookies 明文只在心跳响应通道下行，永不经 GET API） ──
+
+function loginPoolError(res, e) {
+  console.error(`[watchdog] 登录池操作失败: ${e.message}`);
+  sendJSON(res, 400, { error: e.message });
+}
+
+async function handleLoginPoolView(params, body, res) {
+  try {
+    sendJSON(res, 200, { ok: true, ...getLoginPoolView() });
+  } catch (e) {
+    loginPoolError(res, e);
+  }
+}
+
+async function handleLoginPoolAdd(params, body, res) {
+  try {
+    const view = addAccount(body || {});
+    console.error(`[watchdog] 登录池入池: ${view.username}（${view.cookieCount} 条 cookies）`);
+    sendJSON(res, 200, { ok: true, account: view });
+  } catch (e) {
+    loginPoolError(res, e);
+  }
+}
+
+async function handleLoginPoolUpdate(params, body, res) {
+  try {
+    const view = updateAccount(body || {});
+    sendJSON(res, 200, { ok: true, account: view });
+  } catch (e) {
+    loginPoolError(res, e);
+  }
+}
+
+async function handleLoginPoolDelete(params, body, res) {
+  try {
+    const r = deleteAccount((body || {}).id);
+    console.error(`[watchdog] 登录池删除: ${r.username}`);
+    sendJSON(res, 200, { ok: true, ...r });
+  } catch (e) {
+    loginPoolError(res, e);
+  }
+}
+
+async function handleLoginPoolAssign(params, body, res) {
+  try {
+    const view = assignAccount(body || {});
+    console.error(
+      `[watchdog] 登录池指派: ${view.username} → ${body.userId}:${body.port}（下次心跳下发 applyLogin）`,
+    );
+    sendJSON(res, 200, { ok: true, account: view });
+  } catch (e) {
+    loginPoolError(res, e);
+  }
+}
+
+async function handleLoginPoolRelease(params, body, res) {
+  try {
+    const view = releaseAccount(body || {});
+    console.error(`[watchdog] 登录池释放: ${view.username}`);
+    sendJSON(res, 200, { ok: true, account: view });
+  } catch (e) {
+    loginPoolError(res, e);
+  }
+}
+
 // ── 公开 ──
 
 export function registerWatchdogRoutes(httpServer) {
@@ -1226,6 +1315,30 @@ export async function tryHandleWatchdogRoute(
     await handleRecheckLogin(params, body, res);
     return true;
   }
+  if (method === "GET" && routePath === "/api/watchdog/login-pool") {
+    await handleLoginPoolView(params, body, res);
+    return true;
+  }
+  if (method === "POST" && routePath === "/api/watchdog/login-pool/add") {
+    await handleLoginPoolAdd(params, body, res);
+    return true;
+  }
+  if (method === "POST" && routePath === "/api/watchdog/login-pool/update") {
+    await handleLoginPoolUpdate(params, body, res);
+    return true;
+  }
+  if (method === "POST" && routePath === "/api/watchdog/login-pool/delete") {
+    await handleLoginPoolDelete(params, body, res);
+    return true;
+  }
+  if (method === "POST" && routePath === "/api/watchdog/login-pool/assign") {
+    await handleLoginPoolAssign(params, body, res);
+    return true;
+  }
+  if (method === "POST" && routePath === "/api/watchdog/login-pool/release") {
+    await handleLoginPoolRelease(params, body, res);
+    return true;
+  }
   if (method === "POST" && routePath === "/api/watchdog/request-logs") {
     await handleRequestLogs(params, body, res);
     return true;

package/src/watchdog/agent.js

@@ -33,6 +33,7 @@ import {
   DETECT_CAPTCHA_COUNT_THRESHOLD,
 } from "./client-error-monitor.js";
 import { takeoverEnvironment } from "./env-init.js";
+import { applyLoginToPort, clearLoginOnPort } from "./login-apply.js";
 
 // ── 看门狗自身日志入环（供后台页面按需拉取，经 report-logs 回传落盘） ──
 // 包装 console.error：本进程所有 [watchdog]/[llm-analyzer]/[upgrade] 等日志
@@ -259,14 +260,12 @@ export class WatchdogAgent {
    * @param {string} opts.clientId - 客户端标识
    * @param {number} opts.intervalMs - 心跳间隔（毫秒）
    * @param {boolean} [opts.spawnDaemon=true] - 是否自动启动 clash daemon
-   * @param {number} [opts.loginCheckIntervalMs] - 登录检测周期（毫秒），默认 2 小时
    */
   constructor({
     serverUrl,
     clientId,
     intervalMs = 15000,
     spawnDaemon = true,
-    loginCheckIntervalMs = 2 * 60 * 60 * 1000,
   }) {
     this.serverUrl = serverUrl.replace(/\/+$/, "");
     this.clientId = clientId;
@@ -275,17 +274,13 @@ export class WatchdogAgent {
     writeStartedFile();
     this.intervalMs = intervalMs;
     this.spawnDaemon = !!spawnDaemon;
-    this.loginCheckIntervalMs = Math.max(
-      60 * 1000,
-      loginCheckIntervalMs || 2 * 60 * 60 * 1000,
-    );
-    this.loginPorts = []; // 服务端下发的检测端口列表
-    this._loginPortsKey = ""; // 端口列表指纹（变化时立即检测）
-    this.loginReport = null; // 最近一次登录检测结果（随心跳上报）
-    this._loginChecking = false; // 防重入
-    this._lastLoginCheckAt = 0; // 上次检测时间戳
-    this._loginRecheckPending = false; // 服务端下发的手动重检待执行标记
-    this.loginCheckTimer = null;
+    this.loginPorts = []; // 服务端下发的登录检测端口列表（账号启动导入的来源）
+    this._poolQueue = []; // 登录池命令队列（applyLogin/clearLogin，串行执行）
+    this._poolBusy = false; // 池命令 worker 防重入
+    this._poolReports = []; // 池命令执行结果（随下次心跳上报后清空）
+    this._proxySubsSig = null; // 已转发的订阅配置指纹（变化才转发）
+    this._proxySubsSentAt = 0; // 最近一次转发时间戳（daemon applyResult.at 与之比较，只认新失败）
+    this._loginImportDone = false; // 登录态导入：启动首跳执行一次的标记
     this.running = false;
     this.heartbeatTimer = null;
     this.thresholdTimer = null;
@@ -345,6 +340,17 @@ export class WatchdogAgent {
       `[watchdog] 升级: ${isGlobalInstall() ? "已启用" : "跳过（源码模式）"}`,
     );
 
+    // Linux 环境自举（幂等、失败不阻断；Windows/macOS 路径零改动）——
+    // headless 自动补 DISPLAY(Xvfb)、Edge 探测、能力随心跳上报，详见 linux-env-init.js
+    if (process.platform === "linux") {
+      try {
+        const { ensureLinuxEnv } = await import("../lib/linux-env-init.js");
+        this.envCapability = await ensureLinuxEnv();
+      } catch (e) {
+        console.error(`[watchdog] ⚠ Linux 环境自举失败（不阻断）: ${e.message}`);
+      }
+    }
+
     // 把 clientId 写入 ~/.tt-help.json：业务进程上报异常时携带，看门狗按
     // clientId（每台唯一）关联本机条目；克隆机群 hostname 重复不可用
     if (!setWatchdogClientId(this.clientId)) {
@@ -417,14 +423,6 @@ export class WatchdogAgent {
       this._checkProxySwitch();
     }, SWITCH_SCAN_INTERVAL_MS);
 
-    // 登录检测调度：每 60s 检查一次是否到点（首次 60s 后检测，之后每 loginCheckIntervalMs）
-    this.loginCheckTimer = setInterval(() => {
-      this._maybeRunLoginCheck();
-    }, 60_000);
-    setTimeout(() => {
-      this._maybeRunLoginCheck();
-    }, 60_000);
-
     // LLM 日志分析（每 10 分钟调服务端接口）
     this._startLlmAnalyzer();
 
@@ -460,10 +458,6 @@ export class WatchdogAgent {
       clearInterval(this._switchCheckTimer);
       this._switchCheckTimer = null;
     }
-    if (this.loginCheckTimer) {
-      clearInterval(this.loginCheckTimer);
-      this.loginCheckTimer = null;
-    }
     if (this.llmAnalyzerTimer) {
       clearInterval(this.llmAnalyzerTimer);
       this.llmAnalyzerTimer = null;
@@ -800,7 +794,8 @@ export class WatchdogAgent {
       llmAnalysis: this._llmResults,
       clashHealth: getClashHealth(), // daemon 写入的主控制端健康状态（兼容旧版页面）
       clashHealthChannels: getClashHealthChannels(), // 多控制端各通道健康状态
-      loginReport: this.loginReport, // 最近一次登录检测结果
+      loginPool: this._poolReports.length > 0 ? { applied: this._poolReports.splice(0) } : undefined,
+      env: this.envCapability || null, // Linux 环境能力（display/Edge 就绪度；旧服务端忽略）
     };
   }
 
@@ -832,6 +827,44 @@ export class WatchdogAgent {
       const data = await resp.json();
       this.consecutiveFailures = 0;
 
+      // 服务端下发的登录检测端口列表（先于业务拉起处理——启动导入依赖它）
+      if (Array.isArray(data.loginPorts)) {
+        const key = data.loginPorts.join(",");
+        if (key !== this._loginPortsKey) {
+          this._loginPortsKey = key;
+          this.loginPorts = data.loginPorts;
+          console.error(
+            `[watchdog] 登录检测端口（启动导入来源）: ${key || "未配置"}`,
+          );
+        }
+      }
+
+      // 登录态导入（启动首次 loginPorts 到达时执行一次，先于业务拉起；独立步骤，失败不阻塞）
+      // 服务端可下发 loginImport:false 按节点关闭（如无需同步的机器）
+      if (
+        Array.isArray(data.loginPorts) &&
+        data.loginPorts.length > 0 &&
+        data.loginImport !== false &&
+        !this._loginImportDone
+      ) {
+        this._loginImportDone = true;
+        try {
+          const { syncLoginStates } = await import("./login-import.js");
+          const cfg = getClientConfig();
+          const sum = await syncLoginStates({
+            serverUrl: this.serverUrl,
+            userId: cfg.userId,
+            ports: data.loginPorts,
+            proxyServer: cfg.proxy || null,
+          });
+          console.error(
+            `[watchdog] 登录态导入完成: 导入 ${sum.imported.length} · 跳过 ${sum.skipped.length} · 失败 ${sum.failed.length}`,
+          );
+        } catch (e) {
+          console.error(`[watchdog] 登录态导入失败（不阻塞启动）: ${e.message}`);
+        }
+      }
+
       // 同步进程命令
       if (Array.isArray(data.commands)) {
         const prev = this.processManager.runningCount;
@@ -871,6 +904,24 @@ export class WatchdogAgent {
         applyClientConfig(data.clientConfig);
       }
       // 服务端下发的代理订阅配置（变化才转发给 daemon 热应用；daemon 侧幂等）
+      // 重试约定：daemon 应用失败不持久化、结果写 clash-health.json（meta.proxy.applyResult），
+      // 靠 agent 检测到失败后重置 sig 重发全量。若不重置，sig 已消耗、重试链断裂
+      //（两侧约定脱节 → 永远停在「未配置订阅，不拉起」，F-11 踩坑）。
+      if (this._proxySubsSig) {
+        const ar = getClashHealth()?.meta?.proxy?.applyResult;
+        // ar.at > 转发时间戳：只认本轮转发之后新产生的失败结果，避免旧结果误触发重复重发
+        if (
+          ar &&
+          ar.ok === false &&
+          (!this._proxySubsSentAt || ar.at > this._proxySubsSentAt)
+        ) {
+          console.error(
+            `[watchdog] daemon 订阅应用失败: ${ar.error || "未知原因"} → 重置订阅签名，本轮心跳重发`,
+          );
+          this._proxySubsSig = null;
+          this._proxySubsSentAt = 0;
+        }
+      }
       if (
         data.proxySettings &&
         Array.isArray(data.proxySettings.subscriptions)
@@ -878,6 +929,7 @@ export class WatchdogAgent {
         const sig = JSON.stringify(data.proxySettings.subscriptions);
         if (sig !== this._proxySubsSig) {
           this._proxySubsSig = sig;
+          this._proxySubsSentAt = Date.now();
           try {
             const ipc = await import("../clash/ipc.js");
             ipc.writeCommand({
@@ -904,26 +956,18 @@ export class WatchdogAgent {
       if (data.autoUpgrade !== undefined) {
         this._applyAutoUpgradeConfig(data.autoUpgrade);
       }
-      // 服务端下发的登录检测端口列表
-      if (Array.isArray(data.loginPorts)) {
-        const key = data.loginPorts.join(",");
-        if (key !== this._loginPortsKey) {
-          this._loginPortsKey = key;
-          this.loginPorts = data.loginPorts;
-          this._lastLoginCheckAt = 0; // 配置变化 → 立即触发一次检测
-          console.error(
-            `[watchdog] 登录检测端口: ${key || "未配置"}（周期 ${Math.round(this.loginCheckIntervalMs / 60000)} 分钟）`,
-          );
+
+      // 登录池命令（applyLogin/clearLogin）：入队串行执行，结果随下次心跳上报
+      if (data.loginPool && Array.isArray(data.loginPool.commands) && data.loginPool.commands.length > 0) {
+        for (const c of data.loginPool.commands) {
+          if (c && (c.action === "applyLogin" || c.action === "clearLogin") && c.port) {
+            this._poolQueue.push(c);
+          }
         }
-      }
-      // 服务端下发「立即重检」：标记待重检 + 清零上次检测时间，60s 调度器下一跳执行
-      // （重检只检上次未通过的端口，范围在调度器消费时按最新 loginReport 计算）
-      if (data.loginRecheck) {
-        this._loginRecheckPending = true;
-        this._lastLoginCheckAt = 0;
         console.error(
-          "[watchdog] 服务端下发登录重检，下一跳立即执行（仅上次未通过的端口）",
+          `[watchdog] 收到登录池命令 ${data.loginPool.commands.length} 条（队列 ${this._poolQueue.length}），后台串行执行`,
         );
+        this._drainPoolQueue();
       }
 
       // 心跳日志：仅状态变化或每 10 次打印一次
@@ -978,245 +1022,7 @@ export class WatchdogAgent {
     }
   }
 
-  /**
-   * 登录检测调度入口：到点且服务端配置了端口时执行一次检测
-   */
-  _maybeRunLoginCheck() {
-    if (!this.running || this._loginChecking) return;
-    if (!Array.isArray(this.loginPorts) || this.loginPorts.length === 0) return;
-    if (Date.now() - this._lastLoginCheckAt < this.loginCheckIntervalMs) return;
-
-    // 手动重检：只检上次未通过的端口；无有效历史结果退化为全量，全部已登录则跳过
-    let ports = this.loginPorts;
-    if (this._loginRecheckPending) {
-      this._loginRecheckPending = false;
-      const resolved = this._resolveRecheckPorts();
-      if (resolved) {
-        if (resolved.length === 0) {
-          console.error("[watchdog] 重检跳过: 上次全部已登录，无需重检");
-          return; // 不占位，2h 周期照常
-        }
-        ports = resolved;
-        console.error(
-          `[watchdog] 手动重检: 仅检测上次未通过的端口 (${ports.join(",")})`,
-        );
-      }
-      // resolved === null → 无有效历史结果，保持全量
-    }
-
-    this._lastLoginCheckAt = Date.now(); // 先占位，防 60s tick 重入
-    this._runLoginCheck(ports).catch((e) => {
-      console.error(`[watchdog] 登录检测执行失败: ${e.message}`);
-    });
-  }
 
-  /**
-   * 计算手动重检端口范围：上次检测未通过（status !== "logged_in"）的端口，
-   * 含配置了但上次没检到的端口（同样视为未通过）。
-   * @returns {number[]|null} 端口子集；null = 无有效历史结果（调用方退化为全量）
-   */
-  _resolveRecheckPorts() {
-    const report = this.loginReport;
-    if (
-      !report ||
-      report.error ||
-      !Array.isArray(report.ports) ||
-      report.ports.length === 0
-    ) {
-      return null;
-    }
-    const last = new Map(report.ports.map((r) => [Number(r.port), r.status]));
-    return this.loginPorts.filter((p) => last.get(Number(p)) !== "logged_in");
-  }
-
-  /**
-   * 合并登录检测结果：本次检测过的端口用新结果，未检端口保留上次结果。
-   * 全量检测时未检端口为空，行为等同整体替换（与合并前一致）。
-   * @param {Array|null} results 本次端口级结果（null = 无结果，仅保留旧数据）
-   * @param {number[]} checkedPorts 本次实际检测的端口
-   * @param {string} [error] 本次检测的整级错误（可选）
-   */
-  _mergeLoginReport(results, checkedPorts, error) {
-    const prev =
-      this.loginReport && Array.isArray(this.loginReport.ports)
-        ? this.loginReport.ports
-        : [];
-    const checked = new Set(checkedPorts.map(Number));
-    const order = this.loginPorts.map(Number);
-    const byPort = new Map();
-    // 未被本次覆盖的配置端口保留旧结果（配置外残留丢弃，全量检测时行为等同整体替换）
-    for (const r of prev) {
-      const key = Number(r.port);
-      if (!checked.has(key) && order.includes(key)) byPort.set(key, r);
-    }
-    if (Array.isArray(results)) {
-      for (const r of results) byPort.set(Number(r.port), r);
-    }
-    const ports = [...byPort.values()].sort((a, b) => {
-      const ia = order.indexOf(Number(a.port));
-      const ib = order.indexOf(Number(b.port));
-      return (ia < 0 ? order.length : ia) - (ib < 0 ? order.length : ib);
-    });
-    const report = { ports, checkedAt: Date.now() };
-    if (error) report.error = error;
-    return report;
-  }
-
-  /**
-   * 整级失败时的 loginReport：子集重检失败保留未检端口历史结果，全量检测失败整体记错（原行为）
-   */
-  _failedLoginReport(checkedPorts, error) {
-    if (checkedPorts.length < this.loginPorts.length) {
-      return this._mergeLoginReport(null, checkedPorts, error);
-    }
-    return { error, checkedAt: Date.now() };
-  }
-
-  /**
-   * 执行一次登录检测：spawn 子进程跑 tt-help login-check（一次性短任务，不进 ProcessManager）
-   */
-  async _runLoginCheck(portsOverride) {
-    this._loginChecking = true;
-    const ports =
-      Array.isArray(portsOverride) && portsOverride.length > 0
-        ? portsOverride
-        : this.loginPorts;
-    console.error(`[watchdog] 开始登录检测 (端口: ${ports.join(",")})...`);
-    try {
-      // 全局安装用 tt-help 命令；源码模式用 node cli.js
-      const cliPath = join(__dirname, "..", "..", "cli.js");
-      const cmd = isGlobalInstall() ? "tt-help" : process.execPath;
-      const args = isGlobalInstall()
-        ? ["login-check", ports.join(","), "--json"]
-        : [cliPath, "login-check", ports.join(","), "--json"];
-      // 带上 ~/.tt-help.json 里配置的代理（服务端可通过 clientConfig 下发）
-      const cfg = getClientConfig();
-      if (cfg.proxy) args.push("--proxy", cfg.proxy);
-
-      const { stdout, stderr, code } = await new Promise((resolve) => {
-        // Windows 下 tt-help 是 .cmd 包装，必须 shell:true 才能被 cmd.exe 解析
-        // （与 process-manager.startCommand 的 Windows 处理保持一致）
-        const child = IS_WIN
-          ? spawn([cmd, ...args].join(" "), {
-              stdio: ["ignore", "pipe", "pipe"],
-              shell: true,
-              windowsHide: true,
-            })
-          : spawn(cmd, args, {
-              stdio: ["ignore", "pipe", "pipe"],
-            });
-        let out = "",
-          err = "";
-        child.stdout.on("data", (d) => (out += d));
-        child.stderr.on("data", (d) => (err += d));
-        child.on("error", (e) =>
-          resolve({ stdout: out, stderr: err + e.message, code: -1 }),
-        );
-        child.on("close", (c) =>
-          resolve({ stdout: out, stderr: err, code: c }),
-        );
-        // 超时保护 10 分钟（单端口含启动探测最长约 2 分钟）
-        setTimeout(
-          () => {
-            try {
-              child.kill("SIGKILL");
-            } catch {
-              /* ignore */
-            }
-          },
-          10 * 60 * 1000,
-        );
-      });
-
-      if (code !== 0) {
-        // 部分端口失败时 login-check 也会输出完整 JSON（退出码 2）。
-        // 优先采用 stdout 里的 JSON 结果，仅解析失败才记为 error。
-        let partial = null;
-        try {
-          const parsed = JSON.parse(String(stdout).trim());
-          if (Array.isArray(parsed)) partial = parsed;
-        } catch {
-          // stdout 不是 JSON → 走错误分支
-        }
-        if (partial) {
-          this.loginReport = this._mergeLoginReport(partial, ports);
-          console.error(
-            `[watchdog] 登录检测完成(部分失败): ${
-              String(stderr)
-                .split("\n")
-                .filter((l) => l.includes("探测失败"))
-                .slice(-3)
-                .join(" | ")
-                .slice(-300) || "见端口状态"
-            }`,
-          );
-          return;
-        }
-        this.loginReport = this._failedLoginReport(
-          ports,
-          `exit ${code}: ${String(stderr).slice(-500)}`,
-        );
-        console.error(`[watchdog] 登录检测失败: ${this.loginReport.error}`);
-        return;
-      }
-      const parsed = JSON.parse(String(stdout).trim());
-      if (!Array.isArray(parsed)) throw new Error("结果不是数组");
-      this.loginReport = this._mergeLoginReport(parsed, ports);
-      const summary = parsed
-        .map(
-          (r) =>
-            `${r.port}:${r.status}${r.status === "logged_in" && r.account ? "@" + r.account : ""}`,
-        )
-        .join(" ");
-      console.error(`[watchdog] 登录检测完成: ${summary}`);
-    } catch (e) {
-      this.loginReport = this._failedLoginReport(ports, e.message);
-      console.error(`[watchdog] 登录检测异常: ${e.message}`);
-    } finally {
-      this._loginChecking = false;
-    }
-  }
-
-  /**
-   * 处理服务端下发的日志拉取请求（后台页面点击"日志"按钮触发）
-   * 收集本机日志（watchdog 自身环形缓冲 / 进程日志只读快照）→ POST 回传服务端落盘
-   * @param {Array<{cmdId:string, tail?:number}>} requests
-   */
-  async _handleLogRequests(requests) {
-    for (const req of requests) {
-      const cmdId = req && req.cmdId ? String(req.cmdId) : "";
-      if (!cmdId) continue;
-      const tail = Math.max(1, Math.min(Number(req.tail) || 500, 500));
-      let logs = [];
-      if (cmdId === "__watchdog__") {
-        logs = getWatchdogSelfLogs(tail);
-      } else {
-        logs = this.processManager.getProcessLogSnapshot(cmdId, tail);
-      }
-      try {
-        const resp = await fetch(`${this.serverUrl}/api/watchdog/report-logs`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            clientId: this.clientId,
-            cmdId,
-            logs,
-            capturedAt: Date.now(),
-          }),
-          signal: AbortSignal.timeout(20000),
-        });
-        if (!resp.ok) {
-          console.error(
-            `[watchdog] 日志回传失败: ${cmdId} HTTP ${resp.status}`,
-          );
-          continue;
-        }
-        console.error(`[watchdog] 日志回传完成: ${cmdId} (${logs.length}行)`);
-      } catch (e) {
-        console.error(`[watchdog] 日志回传失败: ${cmdId}: ${e.message}`);
-      }
-    }
-  }
 
   /**
    * 启动 LLM 日志分析定时器（每 10 分钟调服务端接口）