tt-help-cli-ycl 1.4.132 → 1.4.135

package/package.json

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

package/scripts/backup-db.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+/**
+ * SQLite 整库备份（WAL 安全）
+ *
+ * 用法:
+ *   node scripts/backup-db.mjs <源.db> [目标.db]
+ *
+ * 默认目标: <源名>-bak-<时间戳>.db（与源同目录）
+ *
+ * 说明:
+ *   - 非只读打开源 → wal_checkpoint(TRUNCATE) 合并 WAL → 物理 cp 主文件
+ *   - 实测 better-sqlite3 的 backup() / VACUUM INTO 在 WAL 模式下会漏掉
+ *     未合并的表（如 tags），唯有物理 cp 主文件可靠（实验验证）
+ *   - 校验用非只读打开目标（readonly 打开会读出不存在的表，造成假象）
+ *     并专项检查 tags 表
+ */
+import fs from "fs";
+import path from "path";
+import Database from "better-sqlite3";
+
+const src = process.argv[2];
+if (!src) {
+  console.error("用法: node scripts/backup-db.mjs <源.db> [目标.db]");
+  process.exit(1);
+}
+const srcPath = path.resolve(src);
+if (!fs.existsSync(srcPath)) {
+  console.error(`源库不存在: ${srcPath}`);
+  process.exit(1);
+}
+const destPath = path.resolve(
+  process.argv[3] ||
+    srcPath.replace(/\.db$/i, `-bak-${Date.now()}.db`),
+);
+fs.mkdirSync(path.dirname(destPath), { recursive: true });
+
+// 1) 非只读打开源 + 强制 WAL checkpoint（把 WAL 合并进主文件）
+const db = new Database(srcPath);
+db.prepare("PRAGMA wal_checkpoint(TRUNCATE)").get();
+const srcTables = db
+  .prepare("SELECT name FROM sqlite_master WHERE type='table'")
+  .all()
+  .map((r) => r.name)
+  .sort();
+db.close();
+
+// 2) 物理复制主文件（此时主文件已含全部数据，cp 即一致快照）
+fs.copyFileSync(srcPath, destPath);
+const size = fs.statSync(destPath).size;
+
+// 3) 校验：非只读打开目标（避免 readonly 假象），对比表清单 + 专项查 tags
+const check = new Database(destPath);
+const destTables = check
+  .prepare("SELECT name FROM sqlite_master WHERE type='table'")
+  .all()
+  .map((r) => r.name)
+  .sort();
+const missing = srcTables.filter((t) => !destTables.includes(t));
+const tagsPresent = destTables.includes("tags");
+check.close();
+
+if (missing.length || !tagsPresent) {
+  const errs = [];
+  if (missing.length) errs.push(`缺失表: ${missing.join(", ")}`);
+  if (!tagsPresent) errs.push("tags 表丢失！");
+  console.error(`❌ 备份校验失败: ${errs.join("；")}`);
+  console.error(`   提示: 源库可能正被占用，请确认无写入进程后再试`);
+  process.exitCode = 1;
+} else {
+  console.log(`✅ 备份完成: ${srcPath}`);
+  console.log(`   目标: ${destPath} (${(size / 1024 / 1024).toFixed(1)} MB)`);
+  console.log(`   表清单一致: ${srcTables.length} 张表（含 tags）`);
+}

package/scripts/check-queues.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+# 一键查询远程服务器 TikTok 双队列状态
+# 用法:
+#   ./scripts/check-queues.sh        # 仅输出两个数字: precheck_48h / pending_refresh
+#   ./scripts/check-queues.sh -d     # 额外输出 pending_refresh 按国家分布
+# 口径（jobs 表，14 国含 US）:
+#   precheck_48h = tt_seller=1 AND verified=0 AND (pending_refresh IS NULL OR 0)
+#                  AND COALESCE(refresh_time,1452000000000) < now-48h
+#   pending_refresh = tt_seller=1 AND verified=0 AND pending_refresh=1
+SERVER="http://117.71.53.99:17301"
+TARGETS="'CZ','GR','HU','PT','ES','PL','NL','BE','DE','FR','IT','IE','AT','US'"
+THRESHOLD=$(( $(date +%s)000 - 172800000 ))
+
+enc() { python3 -c "import urllib.parse,sys;print(urllib.parse.quote(sys.argv[1]))" "$1"; }
+cnt() { python3 -c 'import json,sys
+try: print(json.load(sys.stdin)["rows"][0]["cnt"])
+except Exception: print("ERR")'; }
+
+q() { curl -s --max-time 25 "$SERVER/api/db-query?sql=$(enc "$1")"; }
+
+PC=$(q "SELECT COUNT(*) AS cnt FROM jobs WHERE tt_seller=1 AND verified=0 AND (pending_refresh IS NULL OR pending_refresh=0) AND COALESCE(refresh_time,1452000000000) < $THRESHOLD AND location_created IN ($TARGETS)" | cnt)
+PR=$(q "SELECT COUNT(*) AS cnt FROM jobs WHERE tt_seller=1 AND verified=0 AND pending_refresh=1 AND location_created IN ($TARGETS)" | cnt)
+
+echo "precheck_48h=$PC"
+echo "pending_refresh=$PR"
+
+if [ "${1:-}" = "-d" ]; then
+  echo "--- pending_refresh by country ---"
+  q "SELECT location_created AS country, COUNT(*) AS cnt FROM jobs WHERE tt_seller=1 AND verified=0 AND pending_refresh=1 GROUP BY location_created ORDER BY cnt DESC" \
+    | python3 -c 'import json,sys
+try:
+  rows=json.load(sys.stdin)["rows"]
+  for r in rows:
+    print(r["country"], r["cnt"], sep="\t")
+except Exception as e:
+  print("ERR", e)'
+fi

package/scripts/migrate-jobs-done.mjs

@@ -0,0 +1,124 @@
+/**
+ * jobs_done 冷归档迁移脚本
+ *
+ * 将 jobs 表中 status='done' 且非商家（tt_seller IS NULL OR tt_seller != 1）
+ * 的记录分批迁入新建的 jobs_done 表，并从 jobs 删除。
+ *
+ * 幂等：可重复执行；第二次运行无剩余可迁移记录时直接跳过。
+ * 与 db-schema.js 的 migrateDoneToJobsDone() 逻辑一致，本脚本用于
+ * 部署时在停主程序期间手动执行（避免百万级迁移阻塞 watch 启动）。
+ *
+ * 用法：
+ *   node scripts/migrate-jobs-done.mjs --db=/path/to/result.db [--batch=50000]
+ */
+
+import Database from "better-sqlite3";
+import { existsSync } from "fs";
+
+function parseArg(name, def) {
+  const arg = process.argv.find((a) => a.startsWith(`--${name}=`));
+  return arg ? arg.slice(`--${name}=`.length) : def;
+}
+
+const dbPath = parseArg("db", null);
+const BATCH = Math.max(
+  1,
+  Math.min(100000, parseInt(parseArg("batch", "50000")) || 50000),
+);
+
+if (!dbPath) {
+  console.error(
+    "用法: node scripts/migrate-jobs-done.mjs --db=<主库路径> [--batch=50000]",
+  );
+  process.exit(1);
+}
+if (!existsSync(dbPath)) {
+  console.error(`错误: 数据库不存在: ${dbPath}`);
+  process.exit(1);
+}
+
+const db = new Database(dbPath);
+db.pragma("journal_mode = WAL");
+db.pragma("busy_timeout = 10000");
+
+const DONE_NON_SELLER =
+  "j.status = 'done' AND (j.tt_seller IS NULL OR j.tt_seller != 1)";
+
+// 确保 jobs_done 表存在（结构与 jobs 一致）
+const jdExists = db
+  .prepare(
+    "SELECT 1 FROM sqlite_master WHERE type='table' AND name='jobs_done'",
+  )
+  .get();
+if (!jdExists) {
+  console.error("创建 jobs_done 表...");
+  db.exec("CREATE TABLE jobs_done AS SELECT * FROM jobs WHERE 1=0");
+  db.exec(
+    "CREATE UNIQUE INDEX IF NOT EXISTS idx_jobs_done_pk ON jobs_done(unique_id)",
+  );
+}
+// 补索引
+db.exec(
+  "CREATE INDEX IF NOT EXISTS idx_jobs_done_list ON jobs_done(pinned, processed_at, follower_count, unique_id) WHERE status = 'done'",
+);
+db.exec(
+  "CREATE INDEX IF NOT EXISTS idx_jobs_done_loc ON jobs_done(location_created)",
+);
+db.exec(
+  "CREATE INDEX IF NOT EXISTS idx_jobs_done_status_updated ON jobs_done(status, updated_at) WHERE status = 'done' AND (tt_seller IS NULL OR tt_seller != 1)",
+);
+
+const count = (sql) => db.prepare(sql).get()?.c || 0;
+const beforeJobs = count("SELECT COUNT(*) as c FROM jobs");
+const beforeDone = count("SELECT COUNT(*) as c FROM jobs_done");
+
+console.error(`迁移前: jobs=${beforeJobs}, jobs_done=${beforeDone}`);
+
+let total = 0;
+const start = Date.now();
+for (;;) {
+  const inserted = db
+    .prepare(
+      `INSERT OR IGNORE INTO jobs_done
+       SELECT j.* FROM jobs j
+       LEFT JOIN jobs_done jd ON jd.unique_id = j.unique_id
+       WHERE ${DONE_NON_SELLER} AND jd.unique_id IS NULL
+       LIMIT ?`,
+    )
+    .run(BATCH).changes;
+  const deleted = db
+    .prepare(
+      `DELETE FROM jobs WHERE unique_id IN (
+         SELECT j.unique_id FROM jobs j
+         JOIN jobs_done jd ON jd.unique_id = j.unique_id
+         WHERE ${DONE_NON_SELLER}
+         LIMIT ?
+       )`,
+    )
+    .run(BATCH).changes;
+  if (inserted === 0 && deleted === 0) break;
+  total += Math.max(inserted, deleted);
+  console.error(`  已迁移 ${total} 条...`);
+}
+const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+
+const afterJobs = count("SELECT COUNT(*) as c FROM jobs");
+const afterDone = count("SELECT COUNT(*) as c FROM jobs_done");
+
+// 校验：jobs 中不应再有非商家 done
+const residual = count(
+  `SELECT COUNT(*) as c FROM jobs WHERE status='done' AND (tt_seller IS NULL OR tt_seller != 1)`,
+);
+
+console.error(`迁移完成: 共迁移 ${total} 条（耗时 ${elapsed}s）`);
+console.error(`迁移后: jobs=${afterJobs}, jobs_done=${afterDone}`);
+if (residual > 0) {
+  console.error(
+    `⚠️  jobs 中仍有 ${residual} 条非商家 done 残留（可能被其他进程写入）`,
+  );
+  process.exitCode = 2;
+} else {
+  console.error("校验通过: jobs 中无非商家 done 残留");
+}
+
+db.close();

package/scripts/migrate-tags-db.mjs

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+/**
+ * 迁移 tag 相关 7 张表到独立 tags.db
+ *
+ * 用法:
+ *   node scripts/migrate-tags-db.mjs [主库.db] [目标tags.db]
+ * 默认: ../newdata/result.db → ../newdata/result-tags.db
+ *
+ * 特性:
+ *   - 主库以只读方式打开，不删除任何数据；主库 tags 表保留作回滚兜底
+ *   - 幂等：以主库为准，目标库对应表先 DROP 再全量重建，可重复执行
+ *   - 通过 ATTACH 一次性复制数据 + 复制普通索引（autoindex 随建表自动生成）
+ *
+ * 迁移的 8 张表:
+ *   tags, tag_directions, tag_experiments, tag_analyst_reports,
+ *   cross_country_learnings, discover_log, reflection_rules, tag_optimize_rounds
+ *
+ * 注意：
+ *   - 主库以 readonly 打开，绝不可能被修改；主库 tags 表保留作回滚兜底
+ *   - 采用双连接流式复制（每批 1000 行事务插入），不用 ATTACH
+ *   - 为何不用 ATTACH：实测 ATTACH 一个 WAL 模式的库作为源，会创建其
+ *     -wal/-shm 并导致 schema 解析不一致，甚至破坏源库（tags 表丢失）
+ *   - 幂等：目标库对应表先 DROP 再全量重建，可重复执行
+ */
+import fs from "fs";
+import path from "path";
+import Database from "better-sqlite3";
+
+const TAG_TABLES = [
+  "tags",
+  "tag_directions",
+  "tag_experiments",
+  "tag_analyst_reports",
+  "cross_country_learnings",
+  "discover_log",
+  "reflection_rules",
+  // 历史遗留表（主库存在、代码不再引用，迁移时一并带走）
+  "tag_optimize_rounds",
+];
+
+const mainPath = path.resolve(process.argv[2] || "../newdata/result.db");
+const tagPath = path.resolve(
+  process.argv[3] || mainPath.replace(/\.db$/i, "-tags.db"),
+);
+
+if (!fs.existsSync(mainPath)) {
+  console.error(`主库不存在: ${mainPath}`);
+  process.exit(1);
+}
+
+// 主库 readonly（绝不修改主库）；目标库可写
+const main = new Database(mainPath, { readonly: true });
+fs.mkdirSync(path.dirname(tagPath), { recursive: true });
+const tag = new Database(tagPath);
+tag.pragma("journal_mode = WAL");
+tag.pragma("busy_timeout = 5000");
+
+const report = [];
+const placeholders = TAG_TABLES.map(() => "?").join(",");
+
+// 批量流式复制辅助：把一列行插入目标表
+function streamCopy(srcTable, destTable) {
+  const cols = main
+    .prepare(`SELECT name FROM pragma_table_info('${srcTable}')`)
+    .all()
+    .map((c) => c.name);
+  const colList = cols.join(", ");
+  const stmt = tag.prepare(
+    `INSERT INTO ${destTable} (${colList}) VALUES (${cols.map(() => "?").join(", ")})`,
+  );
+  const insertAll = tag.transaction((rows) => {
+    for (const r of rows) stmt.run(cols.map((c) => r[c]));
+  });
+  const select = main.prepare(`SELECT * FROM ${srcTable}`);
+  let batch = [];
+  let inserted = 0;
+  for (const row of select.iterate()) {
+    batch.push(row);
+    if (batch.length >= 1000) {
+      insertAll(batch);
+      inserted += batch.length;
+      batch = [];
+    }
+  }
+  if (batch.length) {
+    insertAll(batch);
+    inserted += batch.length;
+  }
+  return inserted;
+}
+
+try {
+  // 1) 逐表迁移（目标表先 DROP 再重建，保证幂等）
+  for (const t of TAG_TABLES) {
+    const meta = main
+      .prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name = ?")
+      .get(t);
+    if (!meta || !meta.sql) {
+      report.push(`⚠️  ${t}: 主库不存在，跳过`);
+      continue;
+    }
+    tag.exec(`DROP TABLE IF EXISTS ${t}`);
+    tag.exec(meta.sql);
+    const inserted = streamCopy(t, t);
+    const mainCnt = main.prepare(`SELECT COUNT(*) as c FROM ${t}`).get().c;
+    const tagCnt = tag.prepare(`SELECT COUNT(*) as c FROM ${t}`).get().c;
+    const ok = mainCnt === tagCnt && inserted === mainCnt;
+    report.push(
+      `${ok ? "✅" : "❌"} ${t}: 主库=${mainCnt} 行 / tags.db=${tagCnt} 行 / 迁移=${inserted}${ok ? "" : "  ← 不一致！"}`,
+    );
+  }
+
+  // 2) 复制普通索引（autoindex 由建表 SQL 自动重建，无需复制）
+  const idxRows = main
+    .prepare(
+      `SELECT sql, name FROM sqlite_master
+       WHERE type='index' AND tbl_name IN (${placeholders}) AND sql IS NOT NULL`,
+    )
+    .all(...TAG_TABLES);
+  for (const r of idxRows) {
+    try {
+      tag.exec(r.sql);
+    } catch (e) {
+      report.push(`⚠️  索引 ${r.name} 建立失败: ${e.message}`);
+    }
+  }
+  report.push(`已复制普通索引 ${idxRows.length} 个`);
+
+  // 3) 校验目标库表完整性（只校验主库存在的表，主库不存在的遗留表不报缺失）
+  const missing = [];
+  for (const t of TAG_TABLES) {
+    const inMain = main
+      .prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name = ?")
+      .get(t);
+    if (!inMain) continue;
+    if (
+      !tag
+        .prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?")
+        .get(t)
+    ) {
+      missing.push(t);
+    }
+  }
+  const checkedCount = TAG_TABLES.length - missing.length;
+  report.push(
+    missing.length
+      ? `❌ 目标库缺失表: ${missing.join(", ")}`
+      : `✅ 目标库校验通过（${checkedCount} 张主库存在的表齐全）`,
+  );
+
+  tag.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+} catch (e) {
+  console.error(`❌ 迁移失败: ${e.message}`);
+  process.exitCode = 1;
+} finally {
+  main.close();
+  tag.close();
+}
+
+console.log(`\n主库: ${mainPath}`);
+console.log(`tags.db: ${tagPath}`);
+console.log("----");
+console.log(report.join("\n"));

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();
 }