tt-help-cli-ycl 1.4.132 → 1.4.134

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tt-help-cli-ycl",
-  "version": "1.4.132",
+  "version": "1.4.134",
   "description": "TikTok user & video data scraper - extract ttSeller, verified, locationCreated from HTML source",
   "type": "module",
   "bin": {

package/scripts/test-daemon-failover.mjs

@@ -28,7 +28,9 @@ const state = {
   nodes: ["🇭🇰 香港01", "🇲🇾 马来02"],
   currentNode: "🇭🇰 香港01",
   switches: [],
-  closes: 0,
+  closes: 0, // closeAllConnections（全断）调用次数
+  idleCloses: 0, // closeIdleConnections（优雅断连）调用次数
+  failIdleClose: false, // 模拟优雅断连失败
 };
 
 function resetState() {
@@ -45,6 +47,8 @@ function resetState() {
   state.currentNode = "🇭🇰 香港01";
   state.switches = [];
   state.closes = 0;
+  state.idleCloses = 0;
+  state.failIdleClose = false;
 }
 
 // ── 注册模块 mock（必须在 import daemon.js 之前） ──
@@ -82,6 +86,11 @@ before(async () => {
       closeAllConnections: async () => {
         state.closes += 1;
       },
+      closeIdleConnections: async () => {
+        if (state.failIdleClose) throw new Error("mock 优雅断连失败");
+        state.idleCloses += 1;
+        return { closed: 3, active: 2 };
+      },
     },
   });
   mock.module("../src/clash/ipc.js", {
@@ -119,7 +128,7 @@ test("F1 探针健康：冷却期外首次 failover 即轮换，并更新锚点"
   c._lastSwitchAt = Date.now() - 600_001; // 距上次切换 > 10min 冷却
   await d._handleFailover({ reason: "F1" }, c);
   assert.deepEqual(state.switches, ["🇲🇾 马来02"], "冷却期外应轮换切换");
-  assert.equal(state.closes, 1, "切换后应断开旧连接");
+  assert.equal(state.idleCloses, 1, "切换后应优雅断连（空闲回收）");
   assert.ok(
     c._lastSwitchAt && c._lastSwitchAt > Date.now() - 5000,
     "切换后应更新锚点",
@@ -199,3 +208,24 @@ test("F7 候选集为空：触发 delay 初测且不切换", async () => {
   assert.equal(state.switches.length, 0, "无候选不应切换");
   assert.ok(c._lastProbeAt, "应触发过 delay 初测");
 });
+
+test("F8 优雅断连失败：回退全断，切换仍生效", async () => {
+  resetState();
+  const { d, c } = makeCtx();
+  c._lastSwitchAt = Date.now() - 600_001; // 冷却期外
+  state.failIdleClose = true; // 优雅断连抛错
+  await d._handleFailover({ reason: "F8" }, c);
+  assert.deepEqual(state.switches, ["🇲🇾 马来02"], "切换仍应执行");
+  assert.equal(state.idleCloses, 0, "优雅断连失败未计数");
+  assert.equal(state.closes, 1, "失败后应回退全断");
+});
+
+test("F9 disconnectMode=full：直接全断", async () => {
+  resetState();
+  const { d, c } = makeCtx({ disconnectMode: "full" });
+  c._lastSwitchAt = Date.now() - 600_001;
+  await d._handleFailover({ reason: "F9" }, c);
+  assert.deepEqual(state.switches, ["🇲🇾 马来02"], "切换应执行");
+  assert.equal(state.idleCloses, 0, "full 模式不走优雅断连");
+  assert.equal(state.closes, 1, "full 模式直接全断");
+});

package/src/clash/api.js

@@ -165,6 +165,45 @@ export async function closeConnection(id) {
 export async function closeAllConnections() {
   return request("/connections", { method: "DELETE" });
 }
+
+/**
+ * 优雅断连：只关闭"空闲"连接（两次采样间无流量增长），活跃连接放行让其自然完成
+ * 切换节点后调用：正在进行的请求不被打断，空闲 keep-alive 被回收使新请求立即走新节点
+ * @param {object} [opts]
+ * @param {number} [opts.sampleMs=1000] - 两次采样间隔（毫秒）
+ * @returns {Promise<{closed:number, active:number}>} closed=已断开空闲数, active=放行的活跃/新建数
+ */
+export async function closeIdleConnections({ sampleMs = 1000 } = {}) {
+  const snap1 = await getConnections();
+  await new Promise((r) => setTimeout(r, sampleMs));
+  const snap2 = await getConnections();
+  const map1 = new Map((snap1.connections || []).map((c) => [c.id, c]));
+  const idleIds = [];
+  let active = 0;
+  for (const c of snap2.connections || []) {
+    const c1 = map1.get(c.id);
+    // 新建连接（快照1没有）：可能是刚发起的请求，保守放行避免打断
+    if (!c1) {
+      active++;
+      continue;
+    }
+    if (c1.download === c.download && c1.upload === c.upload)
+      idleIds.push(c.id);
+    else active++;
+  }
+  let closed = 0;
+  await Promise.all(
+    idleIds.map(async (id) => {
+      try {
+        await closeConnection(id);
+        closed++;
+      } catch {
+        /* 单个失败忽略，其余继续 */
+      }
+    }),
+  );
+  return { closed, active };
+}
 export async function getRules() {
   return request("/rules");
 }

package/src/clash/daemon.js

@@ -42,6 +42,10 @@ export class ClashDaemon {
       opts.failoverEscapeAfter > 0
         ? opts.failoverEscapeAfter
         : FAILOVER_ESCAPE_AFTER;
+    // 切换后断连策略：graceful=优雅断连（只断空闲连接，活跃放行），full=全断（紧急回退）
+    this.disconnectMode = opts.disconnectMode === "full" ? "full" : "graceful";
+    this.disconnectSampleMs =
+      opts.disconnectSampleMs > 0 ? opts.disconnectSampleMs : 1000;
     this.dryRun = !!opts.dryRun;
     // 控制端发现参数（CLI 显式值优先，内部再合并 ~/.tt-help.json）
     this._discoverOpts = {
@@ -103,6 +107,31 @@ export class ClashDaemon {
     if (c) c._lastSwitchAt = Date.now();
   }
 
+  /**
+   * 切换后断连（策略可配）：
+   *   graceful（默认）— 优雅断连：只关"空闲"连接（两次采样无流量增长），
+   *                      活跃连接放行自然完成，不打断正在进行的请求；
+   *                      失败回退全断，确保切换即时生效。
+   *   full           — 全量断连（旧行为，紧急回退）。
+   */
+  async _disconnect(c) {
+    if (this.disconnectMode === "full") {
+      await api.closeAllConnections().catch(() => {});
+      return;
+    }
+    try {
+      const r = await api.closeIdleConnections({
+        sampleMs: this.disconnectSampleMs,
+      });
+      this._log(
+        `[${c.proxyPort}] 优雅断连: 空闲 ${r.closed} 断 / 活跃 ${r.active} 放行`,
+      );
+    } catch (e) {
+      this._log(`[${c.proxyPort}] 优雅断连失败，回退全断: ${e.message}`);
+      await api.closeAllConnections().catch(() => {});
+    }
+  }
+
   /**
    * 壳页判定：TikTok SSR 降级响应（HTTP 200 + 无跳转 + 无 error + 无 title）。
    * 壳页 = 加载页（data-downgrade 骨架屏），链路正常、浏览器会自行渲染，不算节点故障。
@@ -435,7 +464,7 @@ export class ClashDaemon {
         await checker.switchToNode(node).catch(() => {});
         this._markSwitch(c, node);
         this._markSwitchTime(c);
-        await api.closeAllConnections().catch(() => {});
+        await this._disconnect(c);
         this._log(
           `✗ [${c.proxyPort}] 恢复原节点 ${node}（原因: ${reason} — 候选全部不可用）`,
         );
@@ -451,9 +480,9 @@ export class ClashDaemon {
       this._log(
         `⚠ [${c.proxyPort}] 节点切换 [巡检异常: ${reason}]: ${node} → ${target} (${h2.timeTotal.toFixed(1)}s ${(h2.sizeDownload / 1024).toFixed(0)}KB)`,
       );
-      // 切换后断开所有旧连接：mihomo 不主动掐旧连接，浏览器 keep-alive 会继续走旧节点
-      // 导致"时好时坏"（实测旧连接可存活 8+ 分钟），必须强制重建才即时生效
-      await api.closeAllConnections().catch(() => {});
+      // 切换后优雅断连：回收空闲 keep-alive 使新请求走新节点；活跃请求放行不打断
+      // 旧连接若不回收会继续走旧节点导致"时好时坏"（实测可存活 8+ 分钟）
+      await this._disconnect(c);
       this._markSwitchTime(c);
       this._writeHealth(c, {
         node: target,
@@ -595,8 +624,8 @@ export class ClashDaemon {
       this._markSwitch(c, cmd.node);
       this._markSwitchTime(c);
       const h = checker.checkNodeHealth();
-      // 切换后断开所有旧连接，浏览器立即重建到新节点（同巡检切换）
-      await api.closeAllConnections().catch(() => {});
+      // 切换后优雅断连：回收空闲连接，活跃放行（同巡检切换）
+      await this._disconnect(c);
       this._log(
         `🔄 看门狗指令: [${c.proxyPort}] 切换完成 (${h.timeTotal.toFixed(1)}s ${(h.sizeDownload / 1024).toFixed(0)}KB, ${h.healthy ? "健康" : "异常"})`,
       );
@@ -700,7 +729,7 @@ export class ClashDaemon {
       if (!target) {
         await checker.switchToNode(node).catch(() => {});
         this._markSwitch(c, node);
-        await api.closeAllConnections().catch(() => {});
+        await this._disconnect(c);
         this._log(
           `✗ failover [${reason}] — 候选全部不可用，恢复原节点 ${node}`,
         );
@@ -712,8 +741,8 @@ export class ClashDaemon {
         });
       }
       this._log(`⚠ 节点切换 [${reason}]: ${node} → ${target}`);
-      // 切换后断开所有旧连接，浏览器立即重建到新节点（同巡检切换）
-      await api.closeAllConnections().catch(() => {});
+      // 切换后优雅断连：回收空闲连接，活跃放行（同巡检切换）
+      await this._disconnect(c);
       this._writeHealth(c, {
         node: target,
         healthy: h2.healthy,
@@ -841,5 +870,7 @@ if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
     failoverCooldownMs: parseInt(getArg("--failover-cooldown-ms")) || undefined,
     failoverEscapeAfter:
       parseInt(getArg("--failover-escape-after")) || undefined,
+    disconnectMode: getArg("--disconnect-mode") || undefined,
+    disconnectSampleMs: parseInt(getArg("--disconnect-sample-ms")) || undefined,
   }).start();
 }

package/src/watch/db-stats.js

@@ -5,7 +5,7 @@
  */
 
 import { getDb } from "./db-schema.js";
-import { getRawJobsCount, getUserDbCount } from "./db-crud.js";
+import { getRawJobsCount } from "./db-crud.js";
 
 export function getDashboardStatsFromDb(targetLocations = [], options = {}) {
   const db = getDb();
@@ -126,15 +126,15 @@ export function getDashboardStatsFromDb(targetLocations = [], options = {}) {
         )
         .get().total;
 
+  // 注：dbTotalUsers（COUNT(*) FROM users）已移除 ——
+  // users 表 3116 万行全表扫约 3s，且仪表盘前端未使用该字段
   const rawJobsCount = skipSlow ? 0 : getRawJobsCount();
-  const dbUsersCount = skipSlow ? 0 : getUserDbCount();
 
   return {
     totalUsers: aggregateRow.total,
     tagCount,
     commentTaskCount,
     rawJobs: rawJobsCount,
-    dbTotalUsers: dbUsersCount,
     jobsTotal: aggregateRow.total,
     jobsBaseTotal: jobsBaseCount,
     jobsPending: aggregateRow.pending,

package/src/watch/server.js

@@ -26,61 +26,59 @@ function getLocalIP() {
 const __dirname = dirname(__filename);
 const publicDir = join(__dirname, "public");
 
-// Stats 缓存：避免每次请求都扫描 100 万+ 条 jobs 数据
+// Stats 缓存：避免每次请求都扫描百万行级大表数据
 let statsCache = null;
 let statsCacheTime = 0;
-const STATS_CACHE_TTL = 15000; // 15 秒缓存
+// 5 分钟缓存：users 表 3116 万行，COUNT 全表扫约 3s；jobs 162 万行，聚合约 2s。
+// 原 15 秒 TTL 导致每 15 秒一次同步大查询，冻结事件循环 5~30s（成簇超时的根因）
+const STATS_CACHE_TTL = 300000; // 5 分钟
 
 // 用户列表短缓存：同一参数组合 3 秒内复用，无论多少客户端同时查只算一次
 const usersCache = new Map(); // key -> { result, time }
 const USERS_CACHE_TTL = 3000; // 3 秒
 
-// 慢计数实时查询（数据库已分拆，直接查无压力）
+// 慢计数查询（分片执行）。
+// 注：dbTotalUsers（COUNT(*) FROM users）已移除 —— users 表 3116 万行全表扫约 3s，
+// 且该字段前端未使用；users 表为判重索引，数据不能删，只能从统计里去掉。
 const SLOW_COUNT_SQLS = {
   rawJobs: "SELECT COUNT(*) as c FROM raw_jobs",
   commentTaskCount:
     "SELECT COUNT(*) as c FROM videos WHERE user_update_count IS NULL OR user_update_count <= 0",
-  dbTotalUsers: "SELECT COUNT(*) as c FROM users",
   tagCount: "SELECT COUNT(*) as c FROM tags",
   tagHighScore: "SELECT COUNT(*) as c FROM tags WHERE score >= 70",
 };
 
-function computeSlowCounts(st) {
-  const result = {};
-  for (const [key, sql] of Object.entries(SLOW_COUNT_SQLS)) {
-    try {
-      const r = st.rawQuery(sql);
-      result[key] = r?.rows?.[0]?.c || 0;
-    } catch (e) {
-      console.error(`[stats] 慢计数 ${key} 查询失败: ${e.message}`);
-      result[key] = 0;
-    }
-  }
-  return result;
-}
-
 let statsRefreshing = false; // 防止并发刷新
 
-function computeStatsIncremental(st) {
-  const now = Date.now();
-  // 缓存有效 → 直接返回
-  if (statsCache && now - statsCacheTime < STATS_CACHE_TTL) {
-    return statsCache;
-  }
-  // 缓存过期但存在 → 先返回旧数据，后台异步刷新
-  if (statsCache && !statsRefreshing) {
-    statsRefreshing = true;
-    setImmediate(async () => {
+// 分片执行统计刷新：每个 SQL 单独一片，片间 setImmediate 让出事件循环，
+// 避免多个大查询连续执行冻结事件循环 5~30 秒（此前成簇超时的直接原因）
+function refreshStatsInShards(st) {
+  const slowKeys = Object.keys(SLOW_COUNT_SQLS);
+  const slowCounts = {};
+
+  function runSlowShard(i) {
+    if (i < slowKeys.length) {
+      const key = slowKeys[i];
+      try {
+        const r = st.rawQuery(SLOW_COUNT_SQLS[key]);
+        slowCounts[key] = r?.rows?.[0]?.c || 0;
+      } catch (e) {
+        console.error(`[stats] 慢计数 ${key} 查询失败: ${e.message}`);
+        slowCounts[key] = 0;
+      }
+      setImmediate(() => runSlowShard(i + 1));
+      return;
+    }
+    // 慢计数全部完成 → dashboard 聚合作为最后一片执行
+    setImmediate(() => {
       try {
-        const slowCounts = computeSlowCounts(st);
         const stats = st.getDashboardStats(DEFAULT_TARGET_LOCATIONS, {
           skipSlowCounts: true,
         });
-        stats.rawJobs = slowCounts.rawJobs;
-        stats.commentTaskCount = slowCounts.commentTaskCount;
-        stats.dbTotalUsers = slowCounts.dbTotalUsers;
-        stats.tagCount = slowCounts.tagCount;
-        stats.tagHighScore = slowCounts.tagHighScore;
+        stats.rawJobs = slowCounts.rawJobs || 0;
+        stats.commentTaskCount = slowCounts.commentTaskCount || 0;
+        stats.tagCount = slowCounts.tagCount || 0;
+        stats.tagHighScore = slowCounts.tagHighScore || 0;
         statsCache = stats;
         statsCacheTime = Date.now();
       } catch (e) {
@@ -89,21 +87,35 @@ function computeStatsIncremental(st) {
         statsRefreshing = false;
       }
     });
+  }
+
+  setImmediate(() => runSlowShard(0));
+}
+
+function computeStatsIncremental(st) {
+  const now = Date.now();
+  // 缓存有效 → 直接返回
+  if (statsCache && now - statsCacheTime < STATS_CACHE_TTL) {
+    return statsCache;
+  }
+  // 缓存过期但存在 → 先返回旧数据，后台分片刷新
+  if (statsCache && !statsRefreshing) {
+    statsRefreshing = true;
+    refreshStatsInShards(st);
     return statsCache;
   }
-  // 首次加载 → 同步计算
-  const slowCounts = computeSlowCounts(st);
+  // 首次加载 → 同步计算 dashboard 基础统计（启动后仅一次），
+  // 慢计数随后台分片补全，不阻塞本次响应之外的请求
   const stats = st.getDashboardStats(DEFAULT_TARGET_LOCATIONS, {
     skipSlowCounts: true,
   });
-  stats.rawJobs = slowCounts.rawJobs;
-  stats.commentTaskCount = slowCounts.commentTaskCount;
-  stats.dbTotalUsers = slowCounts.dbTotalUsers;
-  stats.tagCount = slowCounts.tagCount;
-  stats.tagHighScore = slowCounts.tagHighScore;
   statsCache = stats;
   statsCacheTime = now;
-  return stats;
+  if (!statsRefreshing) {
+    statsRefreshing = true;
+    refreshStatsInShards(st);
+  }
+  return statsCache;
 }
 
 function readBody(req) {