tt-help-cli-ycl 1.4.155 → 1.4.157

package/src/watchdog/agent.js

@@ -28,6 +28,7 @@ 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";
+import { takeoverEnvironment } from "./env-init.js";
 
 // ── 看门狗自身日志入环（供后台页面按需拉取，经 report-logs 回传落盘） ──
 // 包装 console.error：本进程所有 [watchdog]/[llm-analyzer]/[upgrade] 等日志
@@ -320,6 +321,25 @@ export class WatchdogAgent {
     // 注册信号处理
     this._setupSignalHandlers();
 
+    // 环境初始化: 接管旧 agent/旧 daemon + 清理孤儿命令进程，防双开互踩
+    // （2026-09-25 双开乒乓事故修复，详见 env-init.js）
+    try {
+      const takeover = await takeoverEnvironment({
+        spawnDaemon: this.spawnDaemon,
+        selfPid: process.pid,
+      });
+      if (takeover.agents.length || takeover.daemons.length || takeover.orphans.length) {
+        console.error(
+          `[watchdog] 环境初始化: 接管旧 agent ${takeover.agents.length} 个、旧 daemon ${takeover.daemons.length} 个、孤儿命令 ${takeover.orphans.length} 个`,
+        );
+      }
+      // 清空残留 IPC 命令，防止接管后的 daemon 消费过期指令
+      const ipc = await import("../clash/ipc.js");
+      for (const ch of ipc.listCommandChannels()) ipc.clearCommand(ch);
+    } catch (e) {
+      console.error(`[watchdog] 环境初始化异常（不阻塞启动）: ${e.message}`);
+    }
+
     // 启动 clash daemon（保代理通道，--no-daemon 可关闭）
     this._daemonStopping = false;
     if (this._daemonRestartTimer) {
@@ -752,6 +772,25 @@ export class WatchdogAgent {
       if (data.clientConfig) {
         applyClientConfig(data.clientConfig);
       }
+      // 服务端下发的代理订阅配置（变化才转发给 daemon 热应用；daemon 侧幂等）
+      if (data.proxySettings && Array.isArray(data.proxySettings.subscriptions)) {
+        const sig = JSON.stringify(data.proxySettings.subscriptions);
+        if (sig !== this._proxySubsSig) {
+          this._proxySubsSig = sig;
+          try {
+            const ipc = await import("../clash/ipc.js");
+            ipc.writeCommand({
+              action: "setSubscription",
+              subscriptions: data.proxySettings.subscriptions,
+            });
+            console.error(
+              `[watchdog] 下发订阅配置: ${data.proxySettings.subscriptions.length} 条`,
+            );
+          } catch (e) {
+            console.error(`[watchdog] 下发订阅配置失败: ${e.message}`);
+          }
+        }
+      }
       // 服务端下发的错误触发切换配置（默认不启用，后端下发控制）
       if (data.errorTrigger) {
         this._applyErrorTriggerConfig(data.errorTrigger);

package/src/watchdog/env-init.js

@@ -0,0 +1,187 @@
+/**
+ * watchdog 环境初始化 — 新实例启动时接管旧环境
+ *
+ * 解决 2026-09-25 实测踩坑（Mac 本机双开事故）:
+ *   - 双 agent 同跑: 各自批量启动同名命令互杀（webserver 3000 端口乒乓循环）
+ *   - 双 daemon 同跑: 抢同一 mihomo 控制端、共写 health/IPC 文件、切换指令抢消费
+ *   - 孤儿命令进程: 旧实例异常死亡后 webserver/refresh 残留占端口/占 CDP
+ *
+ * 原则: 只清理"同签名"进程，不碰任何无关程序。
+ *   agent 签名  = node + watchdog + (tt-help | main.js | cli.js)
+ *   daemon 签名 = node + clash/daemon.js（仅 spawnDaemon 模式接管，独立部署的 daemon 不动）
+ * 接管顺序: 先 TERM 旧 agent（其退出钩子会自行清理托管子进程），
+ *           等待退出后对残留进程 KILL；孤儿命令进程（ppid=1）一并回收。
+ *
+ * 注意: 若未来用 LaunchAgent/nssm 服务化托管 webserver/refresh（不经 agent），
+ *       孤儿回收需按服务签名加白名单，避免与服务管理器互相拉起。
+ */
+import { execSync } from "node:child_process";
+
+const IS_WIN = process.platform === "win32";
+
+const delay = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/** agent 进程签名（node + watchdog + 启动入口三选一；排除编辑器/grep/bash 包装等含关键字的无关进程） */
+function isAgentCmd(cmd) {
+  if (!/watchdog/.test(cmd) || !/(tt-help|main\.js|cli\.js)/.test(cmd)) return false;
+  if (IS_WIN) return /\bnode\b/.test(cmd); // Windows 可能有 cmd.exe 包装层，宽松匹配
+  return /^(?:[^\s]*[\/\\])?node(\.exe)?\s/.test(cmd); // unix: 首 token 必须是 node
+}
+
+/** clash daemon 进程签名 */
+function isDaemonCmd(cmd) {
+  if (!/clash[\/\\]+daemon\.js/.test(cmd)) return false;
+  if (IS_WIN) return /\bnode\b/.test(cmd);
+  return /^(?:[^\s]*[\/\\])?node(\.exe)?\s/.test(cmd);
+}
+
+/** agent 托管命令进程签名（webserver/refresh，用于孤儿回收） */
+function isManagedCmdCmd(cmd) {
+  if (!/(tt-help|main\.js|cli\.js) (webserver|refresh)\b/.test(cmd)) return false;
+  if (IS_WIN) return /\bnode\b/.test(cmd);
+  return /^(?:[^\s]*[\/\\])?node(\.exe)?\s/.test(cmd);
+}
+
+/** 列出本机进程 [{pid, ppid, cmd}]（跨平台；失败返回空数组 = 跳过本次接管，不阻塞启动） */
+export function listProcesses() {
+  try {
+    if (IS_WIN) {
+      let out;
+      try {
+        // wmic: CSV 首列主机名，末两列 ParentProcessId/ProcessId；cmdline 含逗号用切片解析
+        out = execSync("wmic process get ProcessId,ParentProcessId,CommandLine /format:csv", {
+          encoding: "utf-8",
+          timeout: 15000,
+          windowsHide: true,
+        });
+        const res = [];
+        for (const line of out.split(/\r?\n/)) {
+          if (!line.trim() || /^Node,/i.test(line)) continue;
+          const parts = line.split(",");
+          if (parts.length < 3) continue;
+          const pid = parseInt(parts[parts.length - 1], 10);
+          const ppid = parseInt(parts[parts.length - 2], 10);
+          const cmd = parts.slice(1, parts.length - 2).join(",");
+          if (pid && cmd) res.push({ pid, ppid: ppid || 0, cmd });
+        }
+        return res;
+      } catch {
+        // wmic 被移除（新 Win11）→ PowerShell 兜底
+        out = execSync(
+          "powershell -NoProfile -Command \"Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,CommandLine | ConvertTo-Json -Compress\"",
+          { encoding: "utf-8", timeout: 20000, windowsHide: true },
+        );
+        const j = JSON.parse(out);
+        const arr = Array.isArray(j) ? j : [j];
+        return arr
+          .filter((p) => p && p.ProcessId && p.CommandLine)
+          .map((p) => ({
+            pid: Number(p.ProcessId),
+            ppid: Number(p.ParentProcessId) || 0,
+            cmd: String(p.CommandLine),
+          }));
+      }
+    }
+    const out = execSync("ps -eo pid=,ppid=,command=", { encoding: "utf-8", timeout: 10000 });
+    const res = [];
+    for (const line of out.split("\n")) {
+      const m = line.trim().match(/^(\d+)\s+(\d+)\s+(.+)$/);
+      if (!m) continue;
+      res.push({ pid: Number(m[1]), ppid: Number(m[2]), cmd: m[3] });
+    }
+    return res;
+  } catch {
+    return [];
+  }
+}
+
+const alive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+/** 杀进程树: 先 TERM（agent 类进程的退出钩子会自行清理托管子进程），残留 KILL */
+async function killTree(pid) {
+  if (IS_WIN) {
+    try {
+      execSync(`taskkill /PID ${pid} /T /F`, { stdio: "ignore", timeout: 15000, windowsHide: true });
+    } catch {}
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return;
+  }
+  for (let i = 0; i < 6; i++) {
+    await delay(500);
+    if (!alive(pid)) break;
+  }
+  let kids = [];
+  try {
+    kids = execSync(`pgrep -P ${pid}`, { encoding: "utf-8", timeout: 5000 })
+      .split(/\s+/)
+      .filter(Boolean)
+      .map(Number);
+  } catch {}
+  for (const p of [pid, ...kids]) {
+    if (!alive(p)) continue;
+    try {
+      process.kill(p, "SIGKILL");
+    } catch {}
+  }
+}
+
+/**
+ * 环境接管入口（agent.start() 最先调用）
+ * @param {object} opts
+ * @param {boolean} opts.spawnDaemon - 本实例是否托管 clash daemon（是则接管旧 daemon）
+ * @param {number} opts.selfPid - 自身 pid（排除）
+ * @param {(m: string) => void} [opts.log] - 逐条接管日志
+ * @returns {Promise<{agents: number[], daemons: number[], orphans: number[]}>} 被接管的 pid
+ */
+export async function takeoverEnvironment({ spawnDaemon, selfPid, log = () => {} } = {}) {
+  const procs = listProcesses();
+  const agents = [];
+  const daemons = [];
+
+  for (const p of procs) {
+    if (p.pid === selfPid) continue;
+    if (isAgentCmd(p.cmd)) agents.push(p);
+    else if (spawnDaemon && isDaemonCmd(p.cmd)) daemons.push(p);
+  }
+
+  for (const p of agents) {
+    log(`🧹 环境初始化: 接管旧 watchdog agent (pid ${p.pid}, ${p.cmd.slice(0, 80)})`);
+    await killTree(p.pid);
+  }
+  for (const p of daemons) {
+    log(`🧹 环境初始化: 接管旧 clash daemon (pid ${p.pid})`);
+    await killTree(p.pid);
+  }
+
+  // 孤儿命令进程回收（ppid=1 = 父 agent 已死；仅 unix，Windows 依赖 taskkill /T 树杀）
+  const orphans = [];
+  if (!IS_WIN) {
+    for (const p of listProcesses()) {
+      if (p.pid === selfPid) continue;
+      if (p.ppid === 1 && isManagedCmdCmd(p.cmd)) orphans.push(p);
+    }
+    for (const p of orphans) {
+      log(`🧹 环境初始化: 清理孤儿命令进程 (pid ${p.pid})`);
+      try {
+        process.kill(p.pid, "SIGKILL");
+      } catch {}
+    }
+  }
+
+  return {
+    agents: agents.map((p) => p.pid),
+    daemons: daemons.map((p) => p.pid),
+    orphans: orphans.map((p) => p.pid),
+  };
+}

package/src/watchdog/process-manager.js

@@ -20,6 +20,7 @@ import { pushSelfLog } from "./self-log-buffer.js";
 // === 2026-08-07 变更 ===
 // syncCommands 改为 async，批量启动时每个进程间隔 SPAWN_STAGGER_MS（30s），避免抢网络
 const MAX_RESTART = 3;
+const RESTART_STABLE_MS = 10 * 60 * 1000; // 稳定运行超过此时长后崩溃 → 重新计数（视为新的一轮）
 const MAX_LOG_LINES = 500; // 每个进程最多保留的日志行数
 const IS_WIN = process.platform === "win32";
 const SPAWN_STAGGER_MS = 30000; // syncCommands 批量启动时每个进程间隔 30 秒，避免抢网络
@@ -245,6 +246,10 @@ export class ProcessManager extends EventEmitter {
     super();
     /** @type {Map<string, {cmdId:string, cmdDef:object, child:ChildProcess, startTime:number, restartCount:number, thresholds:object, stopped:boolean}>} */
     this.processes = new Map();
+    /** @type {Map<string, number>} cmdId → 连续异常重启次数（跨实例累计；稳定运行后清零）
+     *  2026-09-25 修复: 原先计数存在每个实例的 info 上，自动重启重建 info 后归零，
+     *  导致 (1/3) 永远不变、MAX_RESTART 熔断失效（双开乒乓循环无熔断的直接原因） */
+    this._restartCounts = new Map();
   }
 
   /**
@@ -352,22 +357,27 @@ export class ProcessManager extends EventEmitter {
       const shouldRestart = !info.stopped && code !== 0;
 
       if (shouldRestart) {
-        const restartCount = (info?.restartCount || 0) + 1;
+        // 跨实例累计 + 稳定运行清零 + 线性退避
+        const restartCount = uptimeMs >= RESTART_STABLE_MS ? 1 : (this._restartCounts.get(id) || 0) + 1;
+        this._restartCounts.set(id, restartCount);
         if (restartCount <= MAX_RESTART) {
+          const delayMs = Math.min(5000 * restartCount, 30000);
           console.error(
-            `[watchdog] 命令 ${id} 异常退出，自动重启 (${restartCount}/${MAX_RESTART})...`,
+            `[watchdog] 命令 ${id} 异常退出，自动重启 (${restartCount}/${MAX_RESTART})，${Math.round(delayMs / 1000)}s 后执行...`,
           );
           this.processes.delete(id);
-          setTimeout(() => this.startCommand(cmdDef), 5000);
+          setTimeout(() => this.startCommand(cmdDef), delayMs);
         } else {
           console.error(
-            `[watchdog] 命令 ${id} 已达最大重启次数 (${MAX_RESTART})，停止重启`,
+            `[watchdog] 命令 ${id} 已达最大重启次数 (${MAX_RESTART})，停止重启（稳定运行 ${Math.round(RESTART_STABLE_MS / 60000)} 分钟后可恢复）`,
           );
           this.processes.delete(id);
+          this._restartCounts.delete(id);
           this.emit("process-crashed", { cmdId: id, cmdDef, code, signal });
         }
       } else {
         this.processes.delete(id);
+        this._restartCounts.delete(id);
       }
     });
 
@@ -435,6 +445,7 @@ export class ProcessManager extends EventEmitter {
       }
     }
 
+    this._restartCounts.delete(cmdId); // 显式停止 = 清空重启计数
     this.processes.delete(cmdId);
   }
 
@@ -479,7 +490,7 @@ export class ProcessManager extends EventEmitter {
                   String(s).padStart(2, "0")
               : m + ":" + String(s).padStart(2, "0");
           })(uptimeSeconds),
-        restartCount: info.restartCount,
+        restartCount: this._restartCounts.get(cmdId) || 0,
         error: info.spawnError || null,
       });
     }
@@ -522,7 +533,7 @@ export class ProcessManager extends EventEmitter {
         cmdId,
         logs: info.logs.slice(), // 快照，避免分析时被修改
         uptimeSeconds: Math.round((Date.now() - info.startTime) / 1000),
-        restartCount: info.restartCount,
+        restartCount: this._restartCounts.get(cmdId) || 0,
       });
       // 清空已读取的日志，避免重复分析
       info.logs = [];