ghprobe 0.1.3 → 0.1.6

package/bin/ghprobe.js

@@ -11,9 +11,14 @@ import { loadConfig, ensureUserConfig, userConfigPath, userConfigSnapshotPath, c
 import { updatePool, poolNeedsUpdate, poolCachePath } from "../src/pool.js";
 import { hasLocalNetwork } from "../src/net.js";
 import { probeNow, startServer } from "../src/server.js";
-import { runHealth, blockFromProbeResult, shouldKeepOldBlock } from "../src/health.js";
-import { mergeHosts, applyHosts, restoreHosts, WIN_HOSTS, acquireHostsLock, releaseHostsLock, runElevated, buildUninstallTaskScript, buildInstallScript, buildHiddenRunnerVbs, userDataDir } from "../src/hosts.js";
+import { runHealth, blockFromProbeResult, shouldKeepOldBlock, parseBlock } from "../src/health.js";
+import { runDoctor, formatReport, queryTask } from "../src/doctor.js";
+import { runStatus, readLogTail } from "../src/status.js";
+import { runDaemon, readHeartbeat, heartbeatFresh, daemonRunning } from "../src/daemon.js";
+import { mergeHosts, applyHosts, restoreHosts, WIN_HOSTS, acquireHostsLock, releaseHostsLock, runElevated, buildUninstallTaskScript, buildInstallScript, buildHiddenRunnerVbs, userDataDir, isPaused, setPaused, buildPauseTaskScript, buildStartTaskScript, rotateLogIfNeeded } from "../src/hosts.js";
+import { maybeNotifyUpdate } from "../src/updates.js";
 import { readFileSync } from "node:fs";
+import { spawn } from "node:child_process";
 
 const ROOT = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
 
@@ -35,16 +40,33 @@ function writeHealthLog(action, reason, extra = {}) {
   const entry = `${new Date().toISOString()} health action=${action} reason=${reason}`
     + `${extra.changed && extra.changed.length ? ` changed=${extra.changed.join(",")}` : ""}`
     + `${extra.stuck && extra.stuck.length ? ` stuck=${extra.stuck.join(",")}` : ""}\n`;
+  appendRawLog(entry);
+}
+
+// 通用日志追加（daemon / 监督者用普通行，health 用上面的带格式行）
+function appendRawLog(line) {
   try {
     const f = healthLogPath();
     fs.mkdirSync(path.dirname(f), { recursive: true });
-    // 新文件写 UTF-8 BOM：否则 PowerShell 5.1 的 Get-Content 会按系统 ANSI 解码，
-    // 中文日志在用户查看时变乱码（文件本身没错，是读取端猜错编码）。
+    // 追加前先滚动：日志只增不减的话，长跑机器几个月能攒出几十 MB（0.1.6 前实测 33MB）
+    rotateLogIfNeeded(f);
     const prefix = fs.existsSync(f) ? "" : "\ufeff";
-    fs.appendFileSync(f, prefix + entry);
+    fs.appendFileSync(f, prefix + line);
   } catch { /* 日志写失败不影响主流程 */ }
 }
 
+// 监督者：daemon 心跳陈旧时拉起新实例（分离进程，继承当前权限，随调用方退出继续存活）。
+// 成功与否都不阻断本轮 —— 本轮 health 照常执行，作为 daemon 就位前的兜底。
+function spawnDaemonDetached() {
+  try {
+    const child = spawn(process.execPath, [path.join(ROOT, "bin", "ghprobe.js"), "daemon"], {
+      detached: true, stdio: "ignore", windowsHide: true,
+    });
+    child.unref();
+    return true;
+  } catch { return false; }
+}
+
 // 打印 hosts 块里的 IP 条目（install 完成后回显写入结果）
 function printHostsEntries() {
   try {
@@ -64,6 +86,11 @@ const program = new Command();
 const PKG = JSON.parse(readFileSync(path.join(ROOT, "package.json"), "utf8"));
 program.name("ghprobe").description("GitHub 直连优选：本地 DoH + TLS 证书终审探测 + hosts 生成（无代理）").version(PKG.version);
 
+// 交互命令开头的版本提示（内部每天最多查一次 registry；只提示不自动升级，失败静默）
+function notifyUpdate() {
+  return maybeNotifyUpdate(PKG.version, console.log);
+}
+
 // 打印一轮结果的可读摘要
 function printSummary(r) {
   for (const [domain, rs] of r.ranked) {
@@ -76,6 +103,37 @@ function printSummary(r) {
   }
 }
 
+program.command("doctor")
+  .description("一键自检：网络 / DoH / 探测 / hosts / 计划任务，人话结论 + 下一步建议")
+  .option("-c, --config <path>", "用户配置覆盖")
+  .action(async (opts) => {
+    await notifyUpdate();
+    const cfg = loadConfig(opts.config);
+    console.error("ghprobe 自检中（跑一轮完整探测，约 1 分钟）…");
+    const r = await runDoctor(cfg, (m) => console.error(m));
+    console.log(formatReport(r.checks));
+    if (!r.ok) { process.exitCode = 1; }
+  });
+
+program.command("daemon")
+  .description("常驻自愈循环（由监督者自动拉起，一般不需要手动跑）：15~45s 自适应健康检查")
+  .option("-c, --config <path>", "用户配置覆盖")
+  .action(async (opts) => {
+    const cfg = loadConfig(opts.config);
+    await runDaemon(cfg, (m) => appendRawLog(`${new Date().toISOString()} ${m}\n`));
+    // 正常不返回；返回即让位/已有实例，静默退出
+  });
+
+program.command("status")
+  .description("秒级速查：hosts 现状 + 自愈日志尾部 + 计划任务（不打任何网络请求）")
+  .option("-c, --config <path>", "用户配置覆盖")
+  .action(async (opts) => {
+    await notifyUpdate();
+    const cfg = loadConfig(opts.config);
+    const r = await runStatus(cfg, { taskQuery: () => queryTask() });
+    console.log(r.lines.join("\n"));
+  });
+
 program.command("probe")
   .description("跑一轮探测并输出结果（不写 hosts）")
   .option("-c, --config <path>", "用户配置覆盖")
@@ -92,10 +150,15 @@ program.command("probe")
     if (opts.json) {
       const out = { at: r.at, domains: [...r.ranked].map(([d, rs]) => ({ domain: d, alive: rs.map((x) => ({ ip: x.ip, tcpMs: x.tcpMs, tlsMs: x.tlsMs, ttfb: x.ttfb, score: x.score })) })), extra: [...r.extra].map(([d, rs]) => ({ domain: d, alive: rs.map((x) => x.ip) })) };
       console.log(JSON.stringify(out, null, 2));
-    } else {
-      printSummary(r);
+      return; // JSON 是给脚本消费的，不掺提示行
     }
+    await notifyUpdate();
+    printSummary(r);
     if (opts.apply) {
+      // 显式命令不受暂停门约束（那是给自动化设的），但要提醒用户自动化还停着
+      if (isPaused()) {
+        console.error("注意：当前处于暂停状态（ghprobe off），本轮按你的显式要求仍写入 hosts；恢复自动化跑 ghprobe on");
+      }
       const lock = acquireHostsLock();
       if (!lock) {
         console.error("另一进程正在写 hosts，本轮跳过（下轮健康检查会自动补写）");
@@ -138,8 +201,28 @@ program.command("health")
   .description("健康检查：只测已写入 IP，异常才全量重排换 IP（加 --apply 才写 hosts）")
   .option("-c, --config <path>", "用户配置覆盖")
   .option("-a, --apply", "检测到异常时写入系统 hosts（会弹 UAC）")
+  .option("-f, --force", "跳过 daemon 监督逻辑，本轮亲自跑（诊断用）")
   .action(async (opts) => {
+    // ghprobe off 后自愈彻底停手：不探测、不写 hosts、不拉 daemon（标记由 off/on 维护）
+    if (isPaused()) {
+      console.error("ghprobe 处于暂停状态（ghprobe off），本轮跳过 —— 恢复跑 ghprobe on");
+      writeHealthLog("skip", "已暂停（ghprobe off），本轮不探测不写 hosts");
+      return;
+    }
     let cfg = loadConfig(opts.config);
+    // 0.5.0 监督者逻辑：daemon 心跳新鲜 -> 秒退（它在干活，重复探测纯属浪费）；
+    // 心跳陈旧/没有 -> 拉起新 daemon（分离进程），本轮仍照常执行，作为 daemon 就位前的兜底。
+    // daemon 崩溃 -> 下一分钟这里自动复活它。手动诊断加 --force 绕过。
+    if (!opts.force) {
+      const hb = readHeartbeat();
+      if (daemonRunning(hb)) {
+        writeHealthLog("skip", "daemon 心跳新鲜，本轮交给 daemon");
+        return;
+      }
+      if (spawnDaemonDetached()) {
+        appendRawLog(`${new Date().toISOString()} supervisor action=spawn-daemon reason=${hb ? "心跳陈旧" : "无心跳"}\n`);
+      }
+    }
     // 本地断网 -> 直接跳过：所有候选必然全灭，跑一轮只会刷屏并把真故障淹掉。
     if (!(await hasLocalNetwork(cfg))) {
       console.error("本地无网络连接，跳过本轮（不探测、不更新池、不写 hosts）");
@@ -148,9 +231,13 @@ program.command("health")
     }
     // 到点先更新候选池（默认每天 1 次；成功失败同一档冷却，不会反复重试）。
     // 放最前：池子新了，后面的重排才有更宽的候选可用；更新成功后重新加载配置以吃进新池。
+    // 0.4.0 自救：把 hosts 里**当前已写入的条目**一并当种子 —— 它们刚通过三关终审，
+    // 是「当下确实能直连 GitHub」的 IP；seed 池被 SNI 整段封锁时这批 IP 往往是
+    // 唯一还拉得到 meta 的入口，池子不至于永久冻结。
     if (poolNeedsUpdate(cfg)) {
       try {
-        await updatePool(cfg, (m) => console.error(m));
+        const cur = parseBlock(fs.readFileSync(WIN_HOSTS, "utf8"));
+        await updatePool(cfg, (m) => console.error(m), [...cur.entries.values()]);
         cfg = loadConfig(opts.config);
       } catch (e) {
         console.error(`候选池更新失败（忽略，用现有池继续）: ${e.message}`);
@@ -165,6 +252,7 @@ program.command("install")
   .option("-c, --config <path>", "用户配置覆盖（间隔取 schedule.healthMin 分钟）")
   .option("--skip-probe", "只注册计划任务，不立即探测写 hosts（等下一次定时触发）")
   .action(async (opts) => {
+    await notifyUpdate();
     // 生成用户可编辑的配置文件（已存在则不覆盖，保留用户改动）
     const ucfg = ensureUserConfig();
     const cfg = loadConfig(opts.config);
@@ -231,9 +319,55 @@ program.command("install")
     console.log("停止：ghprobe uninstall");
   });
 
+program.command("off")
+  .description("一键暂停：剥掉 hosts 块 + 暂停计划任务 + 落暂停标记（自愈停止写入）。GitHub 回到系统默认解析；恢复用 ghprobe on")
+  .action(async () => {
+    // 先落标记：off 与计划任务正在跑的一轮是并发的，标记是第一动作才能保证
+    // 正在跑的那轮也看到暂停，不会刚剥完块又被那一轮写回去
+    setPaused(true);
+    let taskOk = true;
+    try {
+      const r = await runElevated(buildPauseTaskScript(true));
+      if (r.code !== 0) { taskOk = false; console.error(`暂停计划任务失败: ${r.err || r.out}`); }
+    } catch (e) { taskOk = false; console.error(`暂停计划任务失败: ${e.message}`); }
+    try {
+      await restoreHosts();
+      console.log("已暂停：hosts 块已剥离、DNS 缓存已刷新，GitHub 恢复系统默认解析");
+    } catch (e) {
+      console.error(`剥离 hosts 块失败: ${e.message}（暂停标记已落，自动化不会再写入；hosts 里可能还残留 ghprobe 条目，可手动删或重跑 ghprobe off）`);
+      process.exitCode = 1;
+    }
+    if (taskOk) { console.log("计划任务已暂停，常驻自愈停止写入"); }
+    console.log("恢复：ghprobe on（当场触发一轮健康检查，约 1 分钟内重新写好 hosts）");
+    if (!taskOk) { process.exitCode = 1; }
+  });
+
+program.command("on")
+  .description("恢复（ghprobe off 的逆操作）：清暂停标记 + 恢复计划任务 + 当场触发一轮健康检查")
+  .action(async () => {
+    setPaused(false);
+    let ok = true;
+    try {
+      const r = await runElevated(buildPauseTaskScript(false));
+      if (r.code !== 0) { ok = false; console.error(`恢复计划任务失败: ${r.err || r.out}`); }
+    } catch (e) { ok = false; console.error(`恢复计划任务失败: ${e.message}`); }
+    if (ok) {
+      try {
+        const r = await runElevated(buildStartTaskScript());
+        if (r.code !== 0) { console.error(`当场触发失败: ${r.err || r.out}（不致命，下一个间隔任务会自动跑）`); }
+        else { console.log("已当场触发一轮健康检查，约 1 分钟内 hosts 重新写好"); }
+      } catch (e) { console.error(`当场触发失败: ${e.message}（不致命，下一个间隔任务会自动跑）`); }
+    } else {
+      process.exitCode = 1;
+    }
+    console.log("已恢复：ghprobe 自动自愈回到工作状态");
+  });
+
 program.command("uninstall")
   .description("删除 ghprobe 计划任务并还原 hosts")
   .action(async () => {
+    // 暂停标记一并清掉：重装 = 全新开始，不要把上一次的 off 状态带进新装
+    setPaused(false);
     // 两步互相独立：任一步失败都不影响另一步，最后统一置 exitCode
     try {
       await restoreHosts();
@@ -262,7 +396,9 @@ program.command("update-pool")
   .action(async (opts) => {
     const cfg = loadConfig(opts.config);
     try {
-      const r = await updatePool(cfg, (m) => console.error(m));
+      // 手动更新同样带上健康 hosts 条目当备用种子（见 health 命令里的说明）
+      const cur = parseBlock(fs.readFileSync(WIN_HOSTS, "utf8"));
+      const r = await updatePool(cfg, (m) => console.error(m), [...cur.entries.values()]);
       console.log(`候选池已更新：${r.count} 个 IP`);
       console.log(`  经 ${r.via} 拉取 -> ${r.path}`);
       console.log("下次 probe / health 会自动使用 auto 池");
@@ -302,4 +438,68 @@ program.command("config-diff")
     console.log(`配置文件：${userConfigPath()}`);
   });
 
+program.command("report")
+  .description("生成报障诊断包：版本/系统/暂停状态/status/配置差异/hosts 块/日志尾部，复制到剪贴板并落盘（贴 issue 用）")
+  .option("-o, --out <path>", "诊断包写入路径（默认 %LOCALAPPDATA%\\ghprobe\\report-<时间>.txt）")
+  .action(async (opts) => {
+    await notifyUpdate();
+    const cfg = loadConfig();
+    const lines = [];
+    lines.push(`ghprobe ${PKG.version} report`);
+    lines.push(`node ${process.version} / ${process.platform} / os=${os.release()} / ${new Date().toISOString()}`);
+    lines.push(`暂停状态：${isPaused() ? "已暂停（ghprobe off）" : "正常"}`);
+    lines.push("");
+    lines.push("== status ==");
+    try {
+      const r = await runStatus(cfg, { taskQuery: () => queryTask() });
+      lines.push(...r.lines);
+    } catch (e) { lines.push(`status 失败: ${e.message}`); }
+    lines.push("");
+    lines.push("== config-diff ==");
+    try {
+      const { hasUser, diff } = configDiff();
+      lines.push(hasUser ? (diff.length ? `用户配置与默认有 ${diff.length} 处差异：${diff.map((d) => d.key).join(", ")}` : "用户配置与当前默认一致") : "无用户配置（还没跑过 install）");
+    } catch (e) { lines.push(`config-diff 失败: ${e.message}`); }
+    lines.push("");
+    lines.push("== hosts 块 ==");
+    try {
+      const cur = readFileSync(WIN_HOSTS, "utf8");
+      const m = cur.match(/# === ghprobe begin ===[\s\S]*?(?:# === ghprobe end ===|$)/);
+      lines.push(m ? m[0].trimEnd() : "(无 ghprobe 块)");
+    } catch (e) { lines.push(`hosts 读取失败: ${e.message}`); }
+    lines.push("");
+    lines.push("== 自愈日志尾部（最近 50 行） ==");
+    const tail = readLogTail(50);
+    if (tail.length) { lines.push(...tail); } else { lines.push("(暂无日志)"); }
+    lines.push("");
+    lines.push("== 下一步 ==");
+    lines.push("再跑一次 `ghprobe doctor`，把它的输出也贴进 issue（约 1 分钟，report 里放不下探测过程）。");
+    const text = lines.join("\r\n") + "\r\n";
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const out = opts.out || path.join(userDataDir(), `report-${stamp}.txt`);
+    try {
+      fs.mkdirSync(path.dirname(out), { recursive: true });
+      fs.writeFileSync(out, text, "utf8");
+    } catch (e) {
+      console.error(`诊断包落盘失败: ${e.message}`);
+      process.exitCode = 1;
+    }
+    // 尝试复制到剪贴板：失败不影响落盘（诊断包已在文件里）
+    let copied = false;
+    try {
+      await new Promise((resolve) => {
+        const child = spawn("clip", [], { stdio: ["pipe", "ignore", "ignore"] });
+        child.on("error", () => resolve());
+        child.on("close", () => { copied = true; resolve(); });
+        child.stdin.on("error", () => { /* clip 不存在时 write 会 emit，别让它炸进程 */ });
+        child.stdin.write(text);
+        child.stdin.end();
+        setTimeout(resolve, 3000); // clip 偶发不回 close，兜底别挂着
+      });
+    } catch { /* 复制失败不影响落盘 */ }
+    console.log(copied
+      ? `诊断包已复制到剪贴板（可直接粘贴进 issue），同时写在 ${out}`
+      : `诊断包已写入 ${out}（剪贴板复制不可用，请手动打开复制）`);
+  });
+
 program.parseAsync();

package/config.default.yaml

@@ -10,13 +10,22 @@
 #    所以升级后不需要手动同步配置。想看有哪些差异：`ghprobe config-diff`。
 #    （本文件里的注释只是说明，不参与合并 —— 合并看的是键值。）
 # 目标域名族：每域名独立探测、独立写 hosts
+# api.github.com（0.2.0）：gh CLI / REST API 走它，DNS 同样被污染 —— 写进 hosts 后
+#   `gh api` / `curl https://api.github.com` 直连可用；候选走 seed/auto 池（GitHub 自租段）
+# github.githubassets.com（0.3.0）：github.com 网页的全部 JS/CSS/字体都从这里加载 ——
+#   不写它「页面能开但样式全裂」。注意其 Fastly 段是 .215，与 githubusercontent 的 .133 不同
+# ssh.github.com（0.3.0）：SSH-over-443（git clone git@ssh.github.com:... 用），
+#   探测方式是读 SSH banner，不走 TLS/HTTP 三关
 domains:
   - github.com
+  - api.github.com
+  - ssh.github.com
   - codeload.github.com
   - objects.githubusercontent.com
   - raw.githubusercontent.com
   - gist.githubusercontent.com
   - avatars.githubusercontent.com
+  - github.githubassets.com
 
 # DoH 端点（全部 IP 直连，绕开解析 DoH 域名的死锁；默认只放国内实测可达端点）
 # sni 填服务域名：TLS 握手按它验证书（RFC 6066 不允许拿 IP 当 SNI）
@@ -24,6 +33,7 @@ doh:
   - { name: alidns1, host: 223.5.5.5, sni: dns.alidns.com, path: /dns-query }
   - { name: alidns2, host: 223.6.6.6, sni: dns.alidns.com, path: /dns-query }
   - { name: dnspod, host: 1.12.12.12, sni: doh.pub, path: /dns-query }
+  - { name: dnspod2, host: 120.53.53.53, sni: doh.pub, path: /dns-query }
 
 # 内置候选 IP 池：补足 DoH 拿不到的候选。
 # 🔴 池子必须够宽，否则会出现「明明有活 IP，工具却报 stuck」——见下面 azure 段的说明。
@@ -44,6 +54,10 @@ ipPools:
     - 140.82.121.3
   # Fastly 段：服务 githubusercontent 系（raw / objects / gist / avatars），多年不变
   fastly: [185.199.108.133, 185.199.109.133, 185.199.110.133, 185.199.111.133]
+  # Fastly ghassets 段（0.3.0 新增）：github.githubassets.com 专用。
+  # 🔴 与上面 .133 不是同一段：实测 .133 对 github.githubassets.com 的 SNI 连不上，
+  #    DoH 对该域名返回的也是 .215 —— 两段不能混用，所以单独建池。
+  ghassets: [185.199.108.215, 185.199.109.215, 185.199.110.215, 185.199.111.215]
   # GitHub 自租段：服务 github.com / codeload.github.com 主站。
   # 🔴 2026-10 实测：这些 IP **在分钟级抖动** —— 同一批 IP 几分钟前全灭、现在 9/20 可用，
   #    且「活的是哪几个」每次都不一样。所以池子必须宽（靠 tcpMs 短超时兜住成本），
@@ -85,11 +99,14 @@ ipPools:
 # 顺序有意义：靠前的池先占 maxPoolIps 名额。
 domainPools:
   github.com: [auto, seed, azure]
+  api.github.com: [auto, seed]
+  ssh.github.com: [auto, seed]
   codeload.github.com: [auto, seed, azure]
   objects.githubusercontent.com: [fastly]
   raw.githubusercontent.com: [fastly]
   gist.githubusercontent.com: [fastly]
   avatars.githubusercontent.com: [fastly]
+  github.githubassets.com: [ghassets]
 
 # 候选池自动更新：从 GitHub 官方 api.github.com/meta 拉最新网段，缓存到用户目录，供 `auto` 池使用。
 # 为什么需要：GitHub 的 Azure 段在变，内置 azure 池会过期（实测 24 个里 4 个已失效）。
@@ -126,16 +143,19 @@ networkCheck:
 #   完整  raw.githubusercontent.com:
 #           - { domain: my.mirror, path: "/gh/torvalds/linux@master/README", mustContain: ["Linux kernel"] }
 # 完整写法**自带探测判据** —— 第三关用它验证「这个 IP 真的在提供这份内容」。
-# 为什么判据必须跟着配置走：不同替身服务的 URL 形态不同，CDN 映射是
-# `/gh/<user>/<repo>@<ref>/<path>`，代理是 `/<完整原始 URL>`，写死在代码里就没法让用户自己加替身。
 #
-# 🔴 兜底域名本身也可能被封：实测 2026-10-11，`cdn.jsdelivr.net` 在当前网络下 TCP 连得上但 TLS 被掐
-#    （被识别的是 TLS ClientHello 的形态，不是 IP）。多候选机制就是为这种情况准备的。
-# 🔴 默认只保留公共 CDN：**不预置任何第三方代理 / 镜像域名**——本工具定位「无代理」，
-#    预置代理域名既与该定位矛盾，也有法律风险。需要更多兜底请自行添加（示例见 README 第 6 节）。
+# 0.4.0 默认链（2026-10-31 实测数据驱动，详见 CHANGELOG）：
+#   - cdn.jsdelivr.net 移除：node + 双 curl 共 45 次全部在 ClientHello 后被 RST（SNI 级硬封），
+#     留着只会白耗每轮 6s 超时；
+#   - fastly.jsdelivr.net 首选：Fastly anycast（151.101.x.229），全栈全 IP 100%、最快（TTFB ~125ms）；
+#   - testingcf.jsdelivr.net 次选：Cloudflare 段，与 Fastly 真正异构；
+#   - gcore.jsdelivr.net 末位：当前 DoH 解析与 testingcf 落在同一对 CF IP（名不副实），纯语义冗余。
+# 🔴 三个替身都不在代码 DOMAIN_SIG 里 —— 必须用完整写法自带判据，否则会退回「探根路径」的弱判据。
 fallbacks:
   raw.githubusercontent.com:
-    - cdn.jsdelivr.net
+    - { domain: fastly.jsdelivr.net, path: "/gh/torvalds/linux@master/README", mustContain: ["Linux kernel"] }
+    - { domain: testingcf.jsdelivr.net, path: "/gh/torvalds/linux@master/README", mustContain: ["Linux kernel"] }
+    - { domain: gcore.jsdelivr.net, path: "/gh/torvalds/linux@master/README", mustContain: ["Linux kernel"] }
 
 # 超时：tcpMs 只管 TCP 握手阶段（死 IP 快速淘汰），握手成功后自动切到 tlsMs。
 # 黑洞 IP 会一直挂到超时，所以这两段必须分开 —— 否则每加一个候选都要多等 tlsMs。
@@ -145,6 +165,15 @@ probe:
   maxPoolIps: 32     # 内置池每域名最多补几个。**与 DoH 各自限额，不共享总上限**（见 probe.js）
   maxPerDomain: 4    # 每域名最多保留几个可用 IP（前 maxEntriesPerDomain 个会写进 hosts）
   concurrency: 10    # 全局同时握手的 socket 上限（跨域名共享）
+  # schannel 二次重探（0.3.0）：Node 的 TLS ClientHello 被中间设备识别并 reset 时
+  # （README §3 实测：同一 IP 同一时刻 openssl 20/20、Node 5/20、浏览器正常），
+  # 改用 Windows 自带的 curl.exe（Schannel 构建，与 Edge 同一 TLS 栈）重探一次。
+  # 0.3.0 前这种情况只能写 # blocked 放弃，而浏览器明明能用 —— 这是假阴性的根治。
+  schannelRetry: true
+  # 复测抗抖动（0.3.0）：对每域名前 3 名再采一枪，均值 + 失败罚分后重排名。
+  # 单采样时同一 IP 相邻两轮分差可达数倍、排名近乎随机，而无谓的换 IP 要刷 DNS 缓存。
+  # 2 = 总采样两次（默认，代价 ~1-2s）；1 或删掉 = 退回单采样旧行为。
+  stableSamples: 2
 # hosts 写入：每域名写几条候选。
 # 🔴 2026-10-11 实测推翻旧假设「Windows 同一域名只取第一条」—— hosts 里同名多条会被
 #    解析器**全部返回**（保持文件顺序），且 curl / 浏览器会**逐个尝试**：黑洞 IP 排在前
@@ -154,6 +183,28 @@ probe:
 hosts:
   maxEntriesPerDomain: 2
 serve: { host: 127.0.0.1, port: 8930 }
+# 用户行为感知的「切换时机」算法（0.6.0，daemon 专用）：
+# 换 IP 有打扰成本（flushdns + 连接池重建，正在看的页面会卡一下）。成本按权重打分：
+#   前台是浏览器 100 > 浏览器在后台跑 30 > 前台是其他软件 10 > 空闲 0
+# 非紧急优化类写入（提上备选/重排优化/补缺失/兜底）在「前台是浏览器」时**推迟**，攒到空闲落地，
+# 上限 deferMaxMs 防饿死；**当前已断的域名（主备全死）不吃权重，立即切** —— 正在用 ≠ 该断网。
+# 检测免管理员：tasklist 扫浏览器进程 + PowerShell GetForegroundWindow 查前台。
+algorithm:
+  enabled: true
+  deferMaxMs: 600000        # 推迟上限（毫秒）：到点强制切，宁可打扰也不能饿死修复
+  deferThreshold: 100       # 成本 >= 此值才推迟（默认只有「前台是浏览器」会到 100）
+  detectCacheMs: 20000      # 活动检测结果缓存（daemon 一轮内不重复打系统）
+  browsers:                 # 视作「浏览器」的进程名（小写，不带 .exe）
+    - chrome
+    - msedge
+    - firefox
+    - brave
+    - opera
+    - vivaldi
+    - 360se
+    - 360chrome
+    - qqbrowser
+    - sogouexplorer
 # 调度：固定频率健康检查，不做指数退避（哨兵一轮 <2s，退避省不下开销反而拉长最坏发现延迟）
 schedule:
   # 哨兵间隔（分钟）：只测已写入 IP（3 条并发，健康时 ~1s），异常才触发全量重排。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ghprobe",
-  "version": "0.1.3",
+  "version": "0.1.6",
   "description": "GitHub direct-connect optimizer: local DoH resolution + TLS-verified probing + hosts generation (no proxy)",
   "keywords": [
     "github",

package/src/algorithm.js

@@ -0,0 +1,173 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// Copyright (C) 2026 zmw
+// algorithm：用户行为感知的「切换时机」决策（0.6.0）。
+//
+// 为什么需要：换 IP 不是零成本的 —— flushdns + 连接池重建，正在浏览的页面会卡一下，
+// 进行中的下载/克隆可能断。0.5.0 及以前 daemon 只看网络健康，不看用户在干什么：
+// 半夜优化切没事，用户正看 GitHub 文档时切就是「打扰」。
+//
+// 决策模型（成本 vs 紧急度）：
+//   成本 = 前台是浏览器(100) > 浏览器在后台跑(30) > 前台是其他软件(10) > 空闲(0)，权重可配
+//   紧急度 = 当前**已经不可用**的域名（主备全死）——这类修复**不吃权重，立即切**：
+//            「正在用」和「不能用」二选一，当然选别断网。
+//   非紧急（提上备选/重排优化/补写缺失/兜底写入）在前台浏览器时推迟，攒成待写块，
+//   空闲时落地；推迟上限 deferMaxMs（默认 10 分钟）防饿死。
+//
+// 检测全部**免管理员**：tasklist 扫浏览器进程 + PowerShell GetForegroundWindow 查前台。
+import { execFile } from "node:child_process";
+
+// 常见浏览器进程名（小写、不带 .exe）。匹配 tasklist 镜像名与前台的 ProcessName。
+export const DEFAULT_BROWSERS = [
+  "chrome", "msedge", "firefox", "brave", "opera", "vivaldi", "360se", "360chrome",
+  "qqbrowser", "sogouexplorer", "maxthon", "twinkstar", "hxbcrowser", "baidubrowser",
+];
+
+// 解析 tasklist /FO CSV /NH 输出 -> 小写进程名 Set（"chrome.exe","123",...）
+export function parseTasklist(out) {
+  const names = new Set();
+  for (const line of String(out || "").split(/\r?\n/)) {
+    const m = line.match(/^"([^"]+)"/);
+    if (m) { names.add(m[1].toLowerCase().replace(/\.exe$/, "")); }
+  }
+  return names;
+}
+
+// 纯函数：进程名集合里有没有浏览器
+export function browserRunningFrom(processNames, browsers) {
+  return (browsers || []).some((b) => processNames.has(String(b).toLowerCase()));
+}
+
+// 活动检测（可注入 exec，测试不打真系统）：
+//   running    = 浏览器进程存在（含后台标签页/更新进程 —— 它们同样会被 flushdns 影响）
+//   foreground = 前台窗口是浏览器（用户正在看网页）
+// PowerShell 查询失败按 foreground=false 处理（保守偏向「可以切」：打扰是体验问题，
+// 断网是可用性问题，检测手段失败时不应把可用性押在一个尽力而为的信号上）。
+export async function detectActivity(cfg, deps = {}) {
+  const exec = deps.exec || execFile;
+  const browsers = cfg.algorithm?.browsers || DEFAULT_BROWSERS;
+  const platform = deps.platform || process.platform;
+  if (platform !== "win32") { return { running: false, foreground: false, source: "non-win32" }; }
+
+  const running = await new Promise((resolve) => {
+    exec("tasklist", ["/FO", "CSV", "/NH"], { windowsHide: true, timeout: 5000 }, (e, stdout) => {
+      if (e) { resolve(false); return; }
+      resolve(browserRunningFrom(parseTasklist(stdout), browsers));
+    });
+  });
+
+  const fgName = await new Promise((resolve) => {
+    const ps = `Add-Type -MemberDefinition '[DllImport("user32.dll")] public static extern IntPtr GetForegroundWindow();[DllImport("user32.dll")] public static extern uint GetWindowThreadProcessId(IntPtr h, out uint p);' -Name FG -Namespace W; $h=[W.FG]::GetForegroundWindow(); $p=0; [W.FG]::GetWindowThreadProcessId($h, [ref]$p) | Out-Null; if ($p) { $pr = Get-Process -Id $p -ErrorAction SilentlyContinue; if ($pr) { Write-Output $pr.ProcessName.ToLower() } }`;
+    exec("powershell", ["-NoProfile", "-Command", ps], { windowsHide: true, timeout: 6000 }, (e, stdout) => {
+      resolve(e ? "" : String(stdout || "").trim().toLowerCase());
+    });
+  });
+
+  return {
+    running,
+    foreground: running && browsers.includes(fgName),
+    fgName,
+    source: fgName ? "foreground-ok" : "foreground-unknown",
+  };
+}
+
+// 成本权重（纯函数）
+export function switchCost(activity, weights = {}) {
+  const w = { browserForeground: 100, browserRunning: 30, otherForeground: 10, idle: 0, ...weights };
+  if (activity.foreground) { return w.browserForeground; }
+  if (activity.running) { return w.browserRunning; }
+  if (activity.otherForeground) { return w.otherForeground; }
+  return w.idle;
+}
+
+// 核心决策（纯函数）。
+//   deadCount   = 当前主备全死的域名数 —— P0，不吃权重
+//   initial     = 首次写入（hosts 里还没有块）—— 无从打扰，直接切
+//   cost        = switchCost 结果
+//   deferSinceMs/nowMs = 本次推迟的起点，超 deferMaxMs 强制切（防饿死）
+export function decideSwitch({ cost = 0, deadCount = 0, initial = false, deferSinceMs = null, nowMs = Date.now(), cfg = {} }) {
+  const a = cfg.algorithm || {};
+  if (a.enabled === false) { return { switch: true, reason: "algorithm 已禁用" }; }
+  if (deadCount > 0) { return { switch: true, reason: `紧急修复（当前不可用域名 ${deadCount} 个，用户正在受影响）` }; }
+  if (initial) { return { switch: true, reason: "首次写入（无从打扰）" }; }
+  if (deferSinceMs != null && nowMs - deferSinceMs >= (a.deferMaxMs ?? 600_000)) {
+    return { switch: true, reason: "推迟已达上限，强制切换" };
+  }
+  const threshold = a.deferThreshold ?? 100;
+  if (cost >= threshold) {
+    return { switch: false, reason: `打扰成本 ${cost} >= 阈值 ${threshold}（用户正在用浏览器），攒到空闲再切` };
+  }
+  return { switch: true, reason: `打扰成本 ${cost} < 阈值 ${threshold}` };
+}
+
+// 门控：交给 runHealth 的 beforeApply 钩子 + daemon 的空闲落地（flush）。
+// 内部状态跨轮存活：deferred 的块存 pendingBlock，用户空闲后由 maybeFlush 落地。
+export function createSwitchGate(deps = {}) {
+  const state = { pendingBlock: null, deferSinceMs: null };
+  const detect = deps.detect || detectActivity;
+
+  async function activityNow(cfg, { fresh = false } = {}) {
+    // 检测结果短缓存：daemon 15~45s 一轮，PS + tasklist 各 ~0.3s，同轮内不重复打系统。
+    // fresh=true 跳过缓存 —— 空闲落地是最终决策点，必须用此刻的真实状态
+    // （用户可能刚离开浏览器；用几秒前的缓存会白白推迟一次）。
+    const ttl = cfg.algorithm?.detectCacheMs ?? 20_000;
+    const now = Date.now();
+    if (!fresh && state.cache && now - state.cache.at < ttl) { return state.cache.activity; }
+    const activity = await detect(cfg, deps);
+    state.cache = { at: now, activity };
+    return activity;
+  }
+
+  return {
+    // runHealth 的 beforeApply 钩子：meta = { deadDomains, initial, changed, reason, block, cfg }
+    async beforeApply(meta) {
+      // P0 短路：用户此刻已经断着 / 首次写入 —— 不检测、不推迟，立即切。
+      // 必须在活动检测之前 return，否则活动检测失败等噪声会把救命修复也拦下来。
+      if ((meta.deadDomains || []).length > 0 || meta.initial) {
+        state.lastReason = meta.initial ? "首次写入" : `紧急修复（不可用域名 ${meta.deadDomains.length} 个）`;
+        return true;
+      }
+      const activity = await activityNow(meta.cfg || {});
+      const cost = switchCost(activity, meta.cfg?.algorithm?.weights);
+      const d2 = decideSwitch({
+        cost,
+        deadCount: 0,
+        initial: false,
+        deferSinceMs: state.deferSinceMs,
+        nowMs: Date.now(),
+        cfg: meta.cfg || {},
+      });
+      if (d2.switch) {
+        state.pendingBlock = null;
+        state.deferSinceMs = null;
+        state.lastReason = d2.reason;
+        return true;
+      }
+      state.pendingBlock = meta.block; // 攒着，空闲时落地
+      state.deferSinceMs = state.deferSinceMs ?? Date.now();
+      state.lastReason = d2.reason;
+      return false;
+    },
+    // daemon 每轮调用：有待写块且此刻成本低 -> 落地
+    async maybeFlush(cfg, log, deps2 = {}) {
+      if (!state.pendingBlock) { return null; }
+      const activity = await activityNow(cfg, { fresh: true });
+      const cost = switchCost(activity, cfg?.algorithm?.weights);
+      const d = decideSwitch({
+        cost, deadCount: 0, initial: false,
+        deferSinceMs: state.deferSinceMs, nowMs: Date.now(), cfg,
+      });
+      if (!d.switch) { return { flushed: false, reason: d.reason }; }
+      const applyHosts = deps.applyHosts || deps2.applyHosts;
+      const hostsPath = deps2?.hostsPath;
+      const merged = deps2.mergeLatest(state.pendingBlock); // 调用方负责读最新 hosts 并合并（护栏在其中）
+      await applyHosts(merged, hostsPath);
+      const block = state.pendingBlock;
+      state.pendingBlock = null;
+      state.deferSinceMs = null;
+      log(`空闲落地：打扰成本 ${cost}，已写入推迟的 hosts 块（${d.reason}）`);
+      return { flushed: true, block };
+    },
+    get pending() { return Boolean(state.pendingBlock); },
+    get lastReason() { return state.lastReason || ""; },
+  };
+}