tt-help-cli-ycl 1.4.56 → 1.4.57

package/src/watch/public/style.css

@@ -1814,3 +1814,46 @@ td.user-id:hover {
 .settings-form .btn-submit:hover {
   background: #e61944;
 }
+
+/* ── 看门狗页面 ── */
+
+#watchdogPage {
+  display: none;
+}
+
+#watchdogPage.active {
+  display: block;
+}
+
+.watchdog-layout {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 20px;
+}
+
+@media (max-width: 900px) {
+  .watchdog-layout {
+    grid-template-columns: 1fr;
+  }
+}
+
+.watchdog-clients,
+.watchdog-commands {
+  background: #1a1a24;
+  border-radius: 12px;
+  padding: 20px;
+}
+
+.watchdog-clients h3,
+.watchdog-commands h3 {
+  font-size: 15px;
+  color: #e0e0e0;
+  margin-bottom: 12px;
+}
+
+.watchdog-clients table th,
+.watchdog-commands table th {
+  font-size: 11px;
+  color: #888;
+  font-weight: 600;
+}

package/src/watch/server.js

@@ -8,6 +8,7 @@ import { fileURLToPath } from "url";
 import { spawn } from "child_process";
 import { createStore } from "./data-store.js";
 import { DEFAULT_TARGET_LOCATIONS } from "../lib/target-locations.js";
+import { tryHandleWatchdogRoute } from "./watchdog-server.js";
 
 const __filename = fileURLToPath(import.meta.url);
 
@@ -423,6 +424,27 @@ export function startWatchServer(
         store.trackClient(clientId, { ip, port: meta.port, userId, type });
       }
 
+      // ── 看门狗路由（独立模块，提前拦截） ──
+      if (routePath.startsWith("/api/watchdog/")) {
+        try {
+          let body = {};
+          if (req.method === "POST") {
+            body = await readBody(req);
+          }
+          const handled = await tryHandleWatchdogRoute(
+            routePath,
+            req.method,
+            params,
+            body,
+            res,
+          );
+          if (handled) return;
+        } catch (e) {
+          sendJSON(res, 400, { error: e.message });
+          return;
+        }
+      }
+
       if (req.method === "POST" && routePath === "/api/users") {
         try {
           const { usernames, sources, guessedLocation } = await readBody(req);

package/src/watch/watchdog-server.js

@@ -0,0 +1,239 @@
+/**
+ * 看门狗服务端模块 — 客户端管理 + 每客户端独立命令列表
+ *
+ * 独立模块。每条命令是完整命令行字符串（如 "tt-help explore --location DE"），
+ * 按 userId（~/.tt-help.json 的 userId 字段）分组存储。
+ */
+
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const homeDir = homedir() || process.env.HOME || process.env.USERPROFILE || "";
+const WATCHDOG_CONFIG_PATH = join(homeDir, ".tt-help-watchdog.json");
+
+// ── 内存数据结构 ──
+const clients = new Map();
+const CLIENT_TIMEOUT_MS = 60 * 1000;
+const CLIENT_CLEANUP_MS = 24 * 60 * 60 * 1000; // 离线超过 24h 清理
+
+// ── 配置文件读写 ──
+
+function loadConfig() {
+  try {
+    if (existsSync(WATCHDOG_CONFIG_PATH))
+      return JSON.parse(readFileSync(WATCHDOG_CONFIG_PATH, "utf-8"));
+  } catch {}
+  return {};
+}
+
+function saveConfig(cfg) {
+  try {
+    writeFileSync(WATCHDOG_CONFIG_PATH, JSON.stringify(cfg, null, 2), "utf-8");
+  } catch (e) {
+    console.error(`[watchdog] 保存失败: ${e.message}`);
+  }
+}
+
+// ── 客户端管理 ──
+
+function registerClient(clientId, info) {
+  const existing = clients.get(clientId);
+  const now = Date.now();
+  if (existing) {
+    Object.assign(existing, info, { lastHeartbeat: now });
+  } else {
+    clients.set(clientId, { ...info, lastHeartbeat: now, registeredAt: now });
+  }
+}
+
+function getOnlineClients() {
+  const now = Date.now();
+  // 清理超过 24h 未心跳的死客户端
+  for (const [clientId, info] of clients) {
+    if (now - info.lastHeartbeat > CLIENT_CLEANUP_MS) {
+      clients.delete(clientId);
+      console.error(`[watchdog] 清理离线客户端: ${clientId}`);
+    }
+  }
+  const result = [];
+  for (const [clientId, info] of clients) {
+    const online = now - info.lastHeartbeat < CLIENT_TIMEOUT_MS;
+    result.push({
+      clientId,
+      hostname: info.hostname || "unknown",
+      ip: info.ip || "",
+      ttHelpVersion: info.ttHelpVersion || "unknown",
+      osInfo: info.osInfo || {},
+      config: info.config || {},
+      processes: info.processes || [],
+      lastHeartbeat: info.lastHeartbeat,
+      registeredAt: info.registeredAt,
+      online,
+    });
+  }
+  // 按 hostname 排序
+  result.sort((a, b) => a.hostname.localeCompare(b.hostname));
+  return result;
+}
+
+// ── 每客户端命令管理 ──
+// 命令格式：字符串 "tt-help explore" 或对象 {cmd, enabled, maxUptimeSeconds, maxMemoryMB}
+// 心跳返回已启用的命令对象（含阈值）
+
+function normalizeCmd(c) {
+  if (typeof c === "string")
+    return { cmd: c, enabled: true, maxUptimeSeconds: 0, maxMemoryMB: 0 };
+  return {
+    cmd: c.cmd || "",
+    enabled: c.enabled !== false,
+    maxUptimeSeconds: c.maxUptimeSeconds || 0,
+    maxMemoryMB: c.maxMemoryMB || 0,
+  };
+}
+
+function getClientCommands(userId) {
+  if (!userId) return [];
+  const cfg = loadConfig();
+  const raw = (cfg.clientCommands && cfg.clientCommands[userId]) || [];
+  return raw
+    .map(normalizeCmd)
+    .filter((c) => c.enabled && c.cmd)
+    .map((c) => ({
+      cmd: c.cmd,
+      maxUptimeSeconds: c.maxUptimeSeconds,
+      maxMemoryMB: c.maxMemoryMB,
+    }));
+}
+
+function setClientCommands(userId, commands) {
+  if (!Array.isArray(commands)) return;
+  const cfg = loadConfig();
+  if (!cfg.clientCommands) cfg.clientCommands = {};
+  cfg.clientCommands[userId] = commands;
+  saveConfig(cfg);
+}
+
+// 返回原始数据（含 enabled 状态），供仪表盘使用
+function getAllClientCommandsRaw() {
+  const cfg = loadConfig();
+  return cfg.clientCommands || {};
+}
+
+// ── 工具函数 ──
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => (body += chunk));
+    req.on("end", () => {
+      try {
+        resolve(body ? JSON.parse(body) : {});
+      } catch (e) {
+        reject(e);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+
+function parseQuery(urlString = "/") {
+  const url = new URL(urlString, "http://127.0.0.1");
+  return {
+    path: url.pathname,
+    params: Object.fromEntries(url.searchParams.entries()),
+  };
+}
+
+function sendJSON(res, code, data) {
+  res.writeHead(code, { "Content-Type": "application/json; charset=utf-8" });
+  res.end(JSON.stringify(data));
+}
+
+// ── 路由处理器 ──
+
+async function handleHeartbeat(params, body, res) {
+  const clientId = params.clientId;
+  if (!clientId) {
+    sendJSON(res, 400, { error: "缺少 clientId" });
+    return;
+  }
+
+  registerClient(clientId, {
+    hostname: body.hostname || "unknown",
+    ip: body.ip || "",
+    ttHelpVersion: body.ttHelpVersion || "unknown",
+    osInfo: body.osInfo || {},
+    config: body.config || {},
+    processes: body.processes || [],
+  });
+
+  // 按 userId 返回该客户端的专属命令列表
+  const userId = (body.config && body.config.userId) || "";
+  const commands = getClientCommands(userId);
+  const ts = new Date().toLocaleTimeString("zh-CN", { hour12: false });
+  console.error(
+    `[watchdog ${ts}] 心跳: ${clientId} (${body.hostname || "?"}, user=${userId || "?"}) ${body.processes?.length || 0}进程, 返回${commands.length}条命令`,
+  );
+
+  sendJSON(res, 200, {
+    ok: true,
+    commands,
+    serverTime: Date.now(),
+  });
+}
+
+async function handleGetClients(params, body, res) {
+  const onlineClients = getOnlineClients();
+  const allCmds = getAllClientCommandsRaw();
+  sendJSON(res, 200, {
+    clients: onlineClients,
+    clientCommands: allCmds,
+    configPath: WATCHDOG_CONFIG_PATH,
+  });
+}
+
+async function handleSetClientCommands(params, body, res) {
+  const { userId, commands } = body;
+  if (!userId) {
+    sendJSON(res, 400, { error: "缺少 userId" });
+    return;
+  }
+  if (!Array.isArray(commands)) {
+    sendJSON(res, 400, { error: "commands 必须是数组" });
+    return;
+  }
+  setClientCommands(userId, commands);
+  const ts = new Date().toLocaleTimeString("zh-CN", { hour12: false });
+  console.error(`[watchdog ${ts}] ${userId} 命令已更新: ${commands.length} 条`);
+  sendJSON(res, 200, { ok: true, count: commands.length });
+}
+
+// ── 公开 ──
+
+export function registerWatchdogRoutes(httpServer) {
+  console.error("[watchdog] 看门狗服务端模块已加载");
+  console.error(`[watchdog] 配置文件: ${WATCHDOG_CONFIG_PATH}`);
+}
+
+export async function tryHandleWatchdogRoute(
+  routePath,
+  method,
+  params,
+  body,
+  res,
+) {
+  if (method === "POST" && routePath === "/api/watchdog/heartbeat") {
+    await handleHeartbeat(params, body, res);
+    return true;
+  }
+  if (method === "GET" && routePath === "/api/watchdog/clients") {
+    await handleGetClients(params, body, res);
+    return true;
+  }
+  if (method === "POST" && routePath === "/api/watchdog/client-commands") {
+    await handleSetClientCommands(params, body, res);
+    return true;
+  }
+  return false;
+}

package/src/watchdog/agent.js

@@ -0,0 +1,219 @@
+/**
+ * 看门狗主代理 — 心跳循环 + 命令同步 + 进程编排
+ *
+ * 职责：
+ *   1. 定时向服务端发送心跳（携带系统信息 + 进程状态）
+ *   2. 从服务端拉取命令列表，同步本地进程
+ *   3. 处理信号优雅退出
+ */
+
+import { getSystemInfo, getClientConfig, getLocalIP } from "./reporter.js";
+import { ProcessManager } from "./process-manager.js";
+import {
+  getVersion,
+  performUpgrade,
+  isGlobalInstall,
+  startUpgradeChecker,
+} from "./upgrader.js";
+
+export class WatchdogAgent {
+  /**
+   * @param {object} opts
+   * @param {string} opts.serverUrl - 服务端地址
+   * @param {string} opts.clientId - 客户端标识
+   * @param {number} opts.intervalMs - 心跳间隔（毫秒）
+   */
+  constructor({ serverUrl, clientId, intervalMs = 15000 }) {
+    this.serverUrl = serverUrl.replace(/\/+$/, "");
+    this.clientId = clientId;
+    this.intervalMs = intervalMs;
+    this.running = false;
+    this.heartbeatTimer = null;
+    this.thresholdTimer = null;
+    this.processManager = new ProcessManager();
+    this.consecutiveFailures = 0;
+    this.maxFailures = 10;
+    this.upgradeChecker = null;
+    this.ttHelpVersion = getVersion();
+  }
+
+  /**
+   * 启动看门狗
+   */
+  async start() {
+    if (this.running) return;
+    this.running = true;
+
+    console.error(
+      `[watchdog] 启动 — 客户端: ${this.clientId}, 版本: ${this.ttHelpVersion}, 间隔: ${this.intervalMs / 1000}s`,
+    );
+    console.error(
+      `[watchdog] 升级: ${isGlobalInstall() ? "已启用" : "跳过（源码模式）"}`,
+    );
+
+    // 注册信号处理
+    this._setupSignalHandlers();
+
+    // 首次立即发送心跳
+    await this._sendHeartbeat();
+
+    // 定时心跳
+    this.heartbeatTimer = setInterval(() => {
+      this._sendHeartbeat();
+    }, this.intervalMs);
+
+    // 独立阈值检查（每 5s，不与心跳耦合）
+    this.thresholdTimer = setInterval(() => {
+      this.processManager.checkThresholds();
+    }, 5000);
+
+    // 自动升级检测（仅全局安装模式）
+    this._startUpgradeChecker();
+  }
+
+  /**
+   * 停止看门狗
+   */
+  async stop() {
+    this.running = false;
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.thresholdTimer) {
+      clearInterval(this.thresholdTimer);
+      this.thresholdTimer = null;
+    }
+    if (this.upgradeChecker) {
+      this.upgradeChecker.stop();
+      this.upgradeChecker = null;
+    }
+    this.processManager.stopAll();
+    console.error("[watchdog] 看门狗已停止");
+  }
+
+  /** 构建心跳请求体 */
+  _buildHeartbeatBody() {
+    const sys = getSystemInfo();
+    return {
+      clientId: this.clientId,
+      hostname: sys.hostname,
+      ip: getLocalIP(),
+      ttHelpVersion: this.ttHelpVersion,
+      osInfo: {
+        platform: sys.platform,
+        release: sys.release,
+        arch: sys.arch,
+        cpus: sys.cpus,
+        totalMemoryMB: sys.totalMemoryMB,
+        freeMemoryMB: sys.freeMemoryMB,
+        nodeVersion: sys.nodeVersion,
+        uptime: sys.uptime,
+        loadavg: sys.loadavg,
+      },
+      config: getClientConfig(),
+      processes: this.processManager.getProcessesStatus(),
+    };
+  }
+
+  /**
+   * 发送心跳
+   */
+  async _sendHeartbeat() {
+    if (!this.running) return;
+
+    const body = this._buildHeartbeatBody();
+    const procCount = body.processes.length;
+
+    try {
+      const resp = await fetch(
+        `${this.serverUrl}/api/watchdog/heartbeat?clientId=${encodeURIComponent(this.clientId)}`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body),
+          // Node 18+ 支持 fetch，超时用 AbortController
+          signal: AbortSignal.timeout(10000),
+        },
+      );
+
+      if (!resp.ok) {
+        throw new Error(`HTTP ${resp.status}: ${resp.statusText}`);
+      }
+
+      const data = await resp.json();
+      this.consecutiveFailures = 0;
+
+      // 同步命令
+      if (Array.isArray(data.commands)) {
+        const prev = this.processManager.runningCount;
+        this.processManager.syncCommands(data.commands);
+        const now = this.processManager.runningCount;
+        if (prev !== now) {
+          console.error(
+            `[watchdog] 进程 ${prev} → ${now} (${data.commands.length}条命令)`,
+          );
+        }
+      }
+
+      const ts = new Date().toLocaleTimeString("zh-CN", { hour12: false });
+      console.error(
+        `[watchdog ${ts}] 心跳 OK (${procCount}进程, ${data.commands?.length || 0}条)`,
+      );
+    } catch (e) {
+      this.consecutiveFailures++;
+      console.error(
+        `[watchdog] 心跳失败 (${this.consecutiveFailures}/${this.maxFailures}): ${e.message}`,
+      );
+      if (this.consecutiveFailures >= this.maxFailures) {
+        console.error("[watchdog] 连续心跳失败次数过多，看门狗退出");
+        await this.stop();
+        process.exit(1);
+      }
+    }
+  }
+
+  /**
+   * 启动自动升级检测（每 10 分钟）
+   * 仅全局安装模式下启用
+   */
+  _startUpgradeChecker() {
+    if (!isGlobalInstall()) return;
+
+    this.upgradeChecker = startUpgradeChecker({
+      onUpdateAvailable: async ({ current, latest }) => {
+        console.error(`[upgrade] ${current} → ${latest}`);
+        this.processManager.stopAll();
+
+        const result = await performUpgrade();
+        if (result.success) {
+          this.ttHelpVersion = latest;
+          console.error(`[upgrade] 升级成功`);
+        } else {
+          console.error(`[upgrade] 失败: ${result.output.substring(0, 200)}`);
+        }
+
+        // 立即心跳（同步命令，重启进程）
+        await this._sendHeartbeat();
+      },
+    });
+  }
+
+  /**
+   * 信号处理
+   */
+  _setupSignalHandlers() {
+    let shuttingDown = false;
+
+    const gracefulShutdown = async (signal) => {
+      if (shuttingDown) return;
+      shuttingDown = true;
+      console.error(`\n[watchdog] 收到 ${signal}，正在退出...`);
+      await this.stop();
+      process.exit(0);
+    };
+
+    process.once("SIGINT", () => gracefulShutdown("SIGINT"));
+    process.once("SIGTERM", () => gracefulShutdown("SIGTERM"));
+  }
+}