tt-help-cli-ycl 1.4.56 → 1.4.57

package/src/watchdog/process-manager.js

@@ -0,0 +1,332 @@
+/**
+ * 进程管理器 — 子进程 spawn、监控、生命周期管理
+ *
+ * 功能：
+ *   - 根据命令定义启动子进程
+ *   - 通过 ps 命令获取进程 RSS 内存和运行时长
+ *   - 停止/重启子进程
+ *   - 自动重启崩溃进程（最多 3 次）
+ *   - 与期望命令列表同步（启动缺失的、停止多余的）
+ */
+
+import { spawn, execSync } from "child_process";
+import { EventEmitter } from "events";
+
+const MAX_RESTART = 3;
+
+function getProcessStats(pid) {
+  try {
+    const stdout = execSync(`ps -p ${pid} -o rss=,etime=`, {
+      encoding: "utf-8",
+      timeout: 3000,
+    }).trim();
+    if (!stdout) return null;
+    const parts = stdout.split(/\s+/);
+    const rssKB = parseInt(parts[0], 10);
+    const elapsed = parts.slice(1).join(" ") || "0";
+    return {
+      memoryMB: isNaN(rssKB) ? 0 : Math.round((rssKB / 1024) * 10) / 10,
+      elapsed,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export class ProcessManager extends EventEmitter {
+  constructor() {
+    super();
+    /** @type {Map<string, {cmdId:string, cmdDef:object, child:ChildProcess, startTime:number, restartCount:number, thresholds:object, stopped:boolean}>} */
+    this.processes = new Map();
+  }
+
+  /**
+   * 启动一个命令
+   * @param {object} cmdDef - { id, name, command, args[], enabled }
+   */
+  startCommand(cmdDef) {
+    let { id, command, args = [] } = cmdDef;
+    if (this.processes.has(id)) {
+      // 已有进程在运行（或 stopCommand 还未清理），跳过
+      const existing = this.processes.get(id);
+      if (existing && !existing.stopped) {
+        console.error(`[watchdog] 命令 ${id} 已在运行中，跳过`);
+        return;
+      }
+    }
+
+    console.error(`[watchdog] 启动命令: ${id}`);
+
+    let child;
+    const startTime = Date.now();
+    try {
+      // 有显式 args 则直接 spawn，否则用 sh -c 传递完整命令行（保留引号语义）
+      if (args.length > 0) {
+        child = spawn(command, args, {
+          stdio: ["ignore", "pipe", "pipe"],
+          detached: false,
+        });
+      } else {
+        child = spawn("sh", ["-c", command], {
+          stdio: ["ignore", "pipe", "pipe"],
+          detached: false,
+        });
+      }
+    } catch (e) {
+      console.error(`[watchdog] 启动命令 ${id} 失败: ${e.message}`);
+      this.processes.set(id, {
+        cmdId: id,
+        cmdDef,
+        child: null,
+        startTime,
+        restartCount: 0,
+        stopped: true,
+        spawnError: e.message,
+      });
+      return;
+    }
+
+    child.stdout?.on("data", (data) => {
+      // 静默处理，避免子进程输出撑爆缓冲区
+    });
+
+    child.stderr?.on("data", (data) => {
+      const msg = data.toString().trim();
+      if (msg) {
+        console.error(`[${id}] ${msg.substring(0, 200)}`);
+      }
+    });
+
+    child.on("exit", (code, signal) => {
+      const info = this.processes.get(id);
+      const uptimeMs = Date.now() - (info?.startTime || startTime);
+      console.error(
+        `[watchdog] 命令 ${id} 已退出 (code=${code}, signal=${signal}, 运行${Math.round(uptimeMs / 1000)}s)`,
+      );
+
+      // 仅当 info 存在且 child 匹配时才处理（避免竞态：旧进程退出时新进程已启动）
+      if (!info || info.child !== child) {
+        // 旧进程退出，info 已被替换，无需处理
+        return;
+      }
+
+      // 被显式停止的不重启；正常退出不重启；仅异常退出才尝试重启
+      const shouldRestart = !info.stopped && code !== 0;
+
+      if (shouldRestart) {
+        const restartCount = (info?.restartCount || 0) + 1;
+        if (restartCount <= MAX_RESTART) {
+          console.error(
+            `[watchdog] 命令 ${id} 异常退出，自动重启 (${restartCount}/${MAX_RESTART})...`,
+          );
+          this.processes.delete(id);
+          setTimeout(() => this.startCommand(cmdDef), 5000);
+        } else {
+          console.error(
+            `[watchdog] 命令 ${id} 已达最大重启次数 (${MAX_RESTART})，停止重启`,
+          );
+          this.processes.delete(id);
+          this.emit("process-crashed", { cmdId: id, cmdDef, code, signal });
+        }
+      } else {
+        this.processes.delete(id);
+      }
+    });
+
+    child.on("error", (err) => {
+      console.error(`[watchdog] 命令 ${id} 进程错误: ${err.message}`);
+    });
+
+    this.processes.set(id, {
+      cmdId: id,
+      cmdDef,
+      child,
+      startTime,
+      restartCount: 0,
+      stopped: false,
+    });
+  }
+
+  /**
+   * 停止一个命令（kill 进程组）
+   */
+  stopCommand(cmdId) {
+    const info = this.processes.get(cmdId);
+    if (!info) return;
+
+    console.error(`[watchdog] 停止命令: ${cmdId}`);
+    info.stopped = true;
+
+    if (info.child) {
+      try {
+        // 尝试优雅终止
+        info.child.kill("SIGTERM");
+        // 2 秒后强制 kill
+        setTimeout(() => {
+          try {
+            if (info.child && info.child.exitCode === null) {
+              info.child.kill("SIGKILL");
+            }
+          } catch {}
+        }, 2000);
+      } catch (e) {
+        console.error(`[watchdog] 停止命令 ${cmdId} 失败: ${e.message}`);
+      }
+    }
+
+    this.processes.delete(cmdId);
+  }
+
+  /**
+   * 获取所有运行中进程的状态
+   * @returns {Array<{cmdId:string, pid:number, status:string, memoryMB:number, uptimeSeconds:number, restartCount:number}>}
+   */
+  getProcessesStatus() {
+    const result = [];
+    for (const [cmdId, info] of this.processes) {
+      if (info.stopped) continue;
+      const pid = info.child?.pid || 0;
+      const stats = pid ? getProcessStats(pid) : null;
+      const uptimeSeconds = Math.round((Date.now() - info.startTime) / 1000);
+
+      result.push({
+        cmdId,
+        name: info.cmdDef.name || cmdId,
+        pid,
+        status: info.child
+          ? info.child.exitCode === null
+            ? "running"
+            : "exited"
+          : "error",
+        memoryMB: stats?.memoryMB ?? 0,
+        uptimeSeconds,
+        uptimeDisplay: stats?.elapsed || `${uptimeSeconds}s`,
+        restartCount: info.restartCount,
+        error: info.spawnError || null,
+      });
+    }
+    return result;
+  }
+
+  /**
+   * 与期望命令列表同步：
+   * - 启动期望列表中已启用但未运行的命令
+   * - 停止正在运行但不在期望列表中的命令
+   * @param {Array} expectedCmds - 服务端返回的命令列表，格式 [{cmd, maxUptimeSeconds, maxMemoryMB}]
+   */
+  syncCommands(expectedCmds) {
+    if (!Array.isArray(expectedCmds)) return;
+
+    // 标准化：{cmd, maxUptimeSeconds, maxMemoryMB} → {id, name, command, args, enabled, thresholds}
+    const normalized = expectedCmds
+      .map((c) => {
+        if (typeof c === "string")
+          c = { cmd: c, maxUptimeSeconds: 0, maxMemoryMB: 0 };
+        const cmdLine = (c.cmd || "").trim();
+        if (!cmdLine) return null;
+        const id =
+          cmdLine.length > 60 ? cmdLine.substring(0, 60) + "..." : cmdLine;
+        return {
+          id,
+          name: id,
+          command: cmdLine,
+          args: [],
+          enabled: true,
+          thresholds: {
+            maxUptimeSeconds: c.maxUptimeSeconds || 0,
+            maxMemoryMB: c.maxMemoryMB || 0,
+          },
+        };
+      })
+      .filter(Boolean);
+
+    const expectedIds = new Set(normalized.map((c) => c.id));
+    const runningIds = new Set(
+      [...this.processes.entries()]
+        .filter(([, info]) => !info.stopped)
+        .map(([id]) => id),
+    );
+
+    // 停止不在期望列表中的
+    for (const runningId of runningIds) {
+      if (!expectedIds.has(runningId)) {
+        this.stopCommand(runningId);
+      }
+    }
+
+    // 启动缺失的，并更新已有进程的阈值
+    for (const cmd of normalized) {
+      if (!runningIds.has(cmd.id)) {
+        this.startCommand(cmd);
+      } else {
+        // 更新阈值（可能被管理员修改了）
+        const info = this.processes.get(cmd.id);
+        if (info) info.thresholds = cmd.thresholds;
+      }
+    }
+  }
+
+  /**
+   * 检查所有运行进程是否超过阈值（最长时间 / 最大内存）
+   */
+  checkThresholds() {
+    const now = Date.now();
+    const toRestart = [];
+
+    for (const [cmdId, info] of this.processes) {
+      if (info.stopped || !info.child) continue;
+      const thresholds = info.thresholds || {};
+      const uptimeSeconds = Math.round((now - info.startTime) / 1000);
+      const pid = info.child.pid;
+
+      let reason = "";
+      // 检查运行时长
+      if (
+        thresholds.maxUptimeSeconds > 0 &&
+        uptimeSeconds >= thresholds.maxUptimeSeconds
+      ) {
+        reason = `运行 ${uptimeSeconds}s 超过阈值 ${thresholds.maxUptimeSeconds}s`;
+      }
+      // 检查内存
+      if (!reason && thresholds.maxMemoryMB > 0 && pid) {
+        const stats = pid ? getProcessStats(pid) : null;
+        const memMB = stats?.memoryMB ?? 0;
+        if (memMB > thresholds.maxMemoryMB) {
+          reason = `内存 ${memMB}MB 超过阈值 ${thresholds.maxMemoryMB}MB`;
+        }
+      }
+
+      if (reason) {
+        console.error(`[watchdog] 命令 ${cmdId} ${reason}，强制重启`);
+        toRestart.push({ cmdId, cmdDef: info.cmdDef });
+      }
+    }
+
+    // 逐个停止 + 重启
+    for (const { cmdId, cmdDef } of toRestart) {
+      this.stopCommand(cmdId);
+      this.startCommand(cmdDef);
+    }
+  }
+
+  /**
+   * 停止所有进程
+   */
+  stopAll() {
+    console.error("[watchdog] 正在停止所有子进程...");
+    for (const [cmdId] of this.processes) {
+      this.stopCommand(cmdId);
+    }
+  }
+
+  /**
+   * 运行中的进程数
+   */
+  get runningCount() {
+    let count = 0;
+    for (const [, info] of this.processes) {
+      if (!info.stopped) count++;
+    }
+    return count;
+  }
+}

package/src/watchdog/reporter.js

@@ -0,0 +1,69 @@
+/**
+ * 系统信息收集模块
+ * 收集机器信息 + tt-help 配置，用于上报到看门狗服务端
+ */
+
+import os from "os";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const homeDir = homedir() || process.env.HOME || process.env.USERPROFILE || "";
+const CONFIG_PATH = join(homeDir, ".tt-help.json");
+
+/**
+ * 获取系统信息
+ */
+export function getSystemInfo() {
+  return {
+    hostname: os.hostname(),
+    platform: os.platform(),
+    release: os.release(),
+    arch: os.arch(),
+    cpus: os.cpus().length,
+    totalMemoryMB: Math.round(os.totalmem() / (1024 * 1024)),
+    freeMemoryMB: Math.round(os.freemem() / (1024 * 1024)),
+    nodeVersion: process.version,
+    uptime: Math.round(os.uptime()),
+    loadavg: os.loadavg(),
+  };
+}
+
+/**
+ * 读取 ~/.tt-help.json 的关键配置字段
+ */
+export function getClientConfig() {
+  try {
+    if (existsSync(CONFIG_PATH)) {
+      const cfg = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+      return {
+        server: cfg.server || "",
+        proxy: cfg.proxy || "",
+        browser: cfg.browser || "",
+        userId: cfg.userId || "",
+        maxVideos: cfg.maxVideos,
+        maxComments: cfg.maxComments,
+        maxFollowing: cfg.maxFollowing,
+        maxFollowers: cfg.maxFollowers,
+      };
+    }
+  } catch {
+    // 无配置文件
+  }
+  return {};
+}
+
+/**
+ * 获取本机 IP 地址
+ */
+export function getLocalIP() {
+  const ifaces = os.networkInterfaces();
+  for (const name of Object.keys(ifaces)) {
+    for (const iface of ifaces[name]) {
+      if (iface.family === "IPv4" && !iface.internal) {
+        return iface.address;
+      }
+    }
+  }
+  return "127.0.0.1";
+}

package/src/watchdog/upgrader.js

@@ -0,0 +1,119 @@
+/**
+ * 自动升级模块 — 检测 tt-help-cli-ycl 新版本并执行升级
+ *
+ * 仅全局安装模式启用。每 10 分钟查询 npm registry，
+ * 发现新版本 → 回调通知 agent → agent 负责停进程 → 升级 → 重启。
+ */
+
+import { exec } from "child_process";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_PATH = join(__dirname, "..", "..", "package.json");
+const PACKAGE = "tt-help-cli-ycl";
+const REGISTRY = "https://registry.npmjs.org";
+
+/** 从 package.json 读取当前版本 */
+export function getVersion() {
+  try {
+    return JSON.parse(readFileSync(PKG_PATH, "utf-8")).version || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+/** 是否通过全局 npm 安装运行 */
+export function isGlobalInstall() {
+  const entry = process.argv[1] || "";
+  return (
+    entry.includes(`/node_modules/${PACKAGE}/`) || entry.endsWith("/tt-help")
+  );
+}
+
+/** 查询 npm registry 最新版本 */
+export async function checkForUpdates() {
+  const current = getVersion();
+  try {
+    const resp = await fetch(`${REGISTRY}/${PACKAGE}/latest`, {
+      signal: AbortSignal.timeout(15_000),
+    });
+    if (!resp.ok)
+      return {
+        current,
+        latest: "?",
+        hasUpdate: false,
+        error: `HTTP ${resp.status}`,
+      };
+    const latest = (await resp.json()).version || "?";
+    return {
+      current,
+      latest,
+      hasUpdate: latest !== "?" && current !== "unknown" && latest !== current,
+    };
+  } catch (e) {
+    return { current, latest: "?", hasUpdate: false, error: e.message };
+  }
+}
+
+/** 执行全局升级（异步，不阻塞事件循环，升级期间心跳正常发送） */
+export function performUpgrade() {
+  return new Promise((resolve) => {
+    exec(
+      `npm install -g ${PACKAGE}@latest`,
+      { timeout: 120_000 },
+      (err, stdout, stderr) => {
+        if (err) {
+          resolve({ success: false, output: stderr || err.message });
+        } else {
+          resolve({ success: true, output: stdout.trim() });
+        }
+      },
+    );
+  });
+}
+
+/**
+ * 启动定时升级检测
+ * @param {{intervalMs?: number, onUpdateAvailable?: function}} opts
+ * @returns {{stop: function}}
+ */
+export function startUpgradeChecker({
+  intervalMs = 10 * 60_000,
+  onUpdateAvailable,
+} = {}) {
+  if (!onUpdateAvailable) return { stop() {} };
+
+  let running = true,
+    timer = null,
+    checking = false;
+
+  const check = async () => {
+    if (!running || checking) return;
+    checking = true;
+    try {
+      const r = await checkForUpdates();
+      if (r.hasUpdate) {
+        console.error(`[upgrade] ${r.current} → ${r.latest}，准备升级...`);
+        await onUpdateAvailable(r);
+      }
+    } catch {
+      /* 静默 */
+    } finally {
+      checking = false;
+    }
+  };
+
+  // 首次 30s 后检测，之后按间隔
+  timer = setInterval(check, intervalMs);
+  setTimeout(check, 30_000);
+
+  return {
+    stop() {
+      running = false;
+      clearInterval(timer);
+      timer = null;
+    },
+  };
+}