ghprobe 0.1.3 → 0.1.5

package/src/health.js

@@ -265,15 +265,17 @@ function sameExtras(a, b) {
 }
 
 // 完整一轮健康检查：读 -> 测已写入 -> 决策 -> （异常时）全量探测 + 部分更新
-// write=true 时才真正 applyHosts（会弹 UAC），否则仅预览
-export async function runHealth(cfg, log, write = false, hostsPath = WIN_HOSTS) {
+// write=true 时才真正 applyHosts（会弹 UAC），否则仅预览。
+// hooks.beforeApply（0.6.0，daemon 传）：写前门控 —— meta = { deadDomains, initial, changed,
+// reason, block, cfg }，返回 false 表示「按用户行为算法推迟」，本轮不落盘、块由门控方保存。
+export async function runHealth(cfg, log, write = false, hostsPath = WIN_HOSTS, promote = new Map(), hooks = {}) {
   const say = log || (() => {});
   const content = fs.readFileSync(hostsPath, "utf8");
   const current = parseBlock(content);
 
   if (current.entries.size === 0) {
     say("hosts 无 ghprobe 记录，触发首次全量");
-    return fullUpdate(cfg, log, content, current, targetDomains(cfg), write, hostsPath);
+    return fullUpdate(cfg, log, content, current, targetDomains(cfg), write, hostsPath, promote, hooks);
   }
 
   // 🔴 主条目 + 备选条目一起探活。旧版只探主条目 —— 于是「主 IP 挂了、备选还是好的」
@@ -296,14 +298,22 @@ export async function runHealth(cfg, log, write = false, hostsPath = WIN_HOSTS)
     return { action: "none", reason: decision.reason, block: null, stuck: [] };
   }
 
+  // 主备全死的域名数（0.6.0）：algorithm 门控的 P0 紧急度 —— 用户此刻真的断着
+  const byDomain = new Map();
+  for (const r of probeResults) {
+    if (!byDomain.has(r.domain)) { byDomain.set(r.domain, []); }
+    byDomain.get(r.domain).push(r);
+  }
+  const deadAll = [...byDomain.entries()].filter(([, rs]) => rs.every((r) => !r.ok)).map(([d]) => d);
+
   say(`异常：${decision.reason}`);
-  return fullUpdate(cfg, log, content, current, decision.domains, write, hostsPath, decision.promote);
+  return fullUpdate(cfg, log, content, current, decision.domains, write, hostsPath, decision.promote, hooks, deadAll);
 }
 
 // 全量探测 + 部分更新 + 写回；护栏与粘性都在 applyDelta 里体现。
 // 只探 diagnose 里的域名：典型场景是「github.com 的 IP 死了，codeload / jsdelivr 还活着」，
 // 此时探 1 个域名（~8 个候选）而不是 6 个（~48 个），失败发现到修好的时间从 ~90s 压到 ~20s。
-async function fullUpdate(cfg, log, content, current, diagnose, write, hostsPath = WIN_HOSTS, promote = new Map()) {
+async function fullUpdate(cfg, log, content, current, diagnose, write, hostsPath = WIN_HOSTS, promote = new Map(), hooks = {}, deadAll = []) {
   const say = log || (() => {});
   // diagnose 为空 = 只有「提上备选」要做，没有需要重排的域名 -> 跳过探测，直接写提升结果
   const r = diagnose.length ? await runProbe(cfg, log, diagnose) : { ranked: new Map(), extra: new Map(), raw: [] };
@@ -332,6 +342,18 @@ async function fullUpdate(cfg, log, content, current, diagnose, write, hostsPath
   if (d.sniBlocked.length) { parts.push(`指纹阻断: ${d.sniBlocked.join(", ")}`); }
   const msg = parts.length ? parts.join("；") : "更新缺失域名冷却记录";
   if (write) {
+    // 0.6.0 用户行为门控：P0（有主备全死的域名）/ 首次写入 直接过；
+    // 非紧急优化类在「用户正用浏览器」时被拒 —— 块由门控方保存，空闲后落地。
+    if (hooks.beforeApply) {
+      const ok = await hooks.beforeApply({
+        deadDomains: deadAll, initial: current.entries.size === 0,
+        changed: d.changed, reason: msg, block, cfg,
+      });
+      if (!ok) {
+        say(`按用户行为算法推迟写入（用户正在用浏览器；修复类不受限，上限 10 分钟）`);
+        return { action: "deferred", reason: "按 algorithm 推迟写入（浏览器使用中）", block, stuck: d.stuck };
+      }
+    }
     const lock = acquireHostsLock();
     if (!lock) {
       say("另一进程正在写 hosts，本轮跳过（下轮健康检查会自动补写）");
@@ -340,7 +362,7 @@ async function fullUpdate(cfg, log, content, current, diagnose, write, hostsPath
     try {
       // 锁内重读最新 hosts：探测耗时期间他人可能已改过，避免覆盖别人刚写的新值
       const latest = fs.readFileSync(hostsPath, "utf8");
-      await applyHosts(mergeHosts(latest, block));
+      await applyHosts(mergeHosts(latest, block), hostsPath);
       say(`已写入 hosts：${msg}${stuckNote}`);
     } finally { releaseHostsLock(lock); }
   } else {

package/src/pool.js

@@ -118,13 +118,16 @@ export function fetchFirstMeta(seeds, host, pathName, timeoutMs) {
 }
 
 // 种子 IP：拉 meta 用的直连入口。优先用配置里的 seed 池，再退回 azure / fastly。
-export function seedIps(cfg) {
+// extra：调用方传入的**健康 hosts 条目**（0.4.0 自救）——它们刚通过三关 + HTTP 终审，
+// 是「当下确实能直连 GitHub」的 IP；当 seed 池被 SNI 整段封锁、静态种子全灭时，
+// 这批 IP 往往是唯一还拉得到 meta 的入口，池子不至于永久冻结。
+export function seedIps(cfg, extra = []) {
   const p = cfg.ipPools || {};
-  return [...new Set([...(p.seed || []), ...(p.azure || []), ...(p.fastly || [])])];
+  return [...new Set([...extra, ...(p.seed || []), ...(p.azure || []), ...(p.fastly || [])])];
 }
 
 // 一轮更新：拉 meta -> 展开 -> 写缓存。失败也会写 lastAttempt（冷却），避免每分钟重试撞 60 次/小时限制。
-export async function updatePool(cfg, log = () => {}) {
+export async function updatePool(cfg, log = () => {}, extraSeeds = []) {
   const u = cfg.poolUpdate || {};
   const url = new URL(u.source || "https://api.github.com/meta");
   const host = u.host || url.hostname;
@@ -133,8 +136,8 @@ export async function updatePool(cfg, log = () => {}) {
   const attemptedAt = new Date().toISOString();
   const prev = readPoolCache();
   try {
-    const seeds = seedIps(cfg);
-    if (!seeds.length) { throw new Error("配置里没有种子 IP（ipPools.seed / azure / fastly 全为空）"); }
+    const seeds = seedIps(cfg, extraSeeds);
+    if (!seeds.length) { throw new Error("配置里没有种子 IP（ipPools.seed / azure / fastly 全为空，也没有健康 hosts 条目）"); }
     // 并行试所有种子，第一个成功的立刻返回（实测 8.2s -> 亚秒级；串行时是 2m13s）。
     const { json, via } = await fetchFirstMeta(seeds, host, pathName, timeoutMs);
 

package/src/probe.js

@@ -3,7 +3,7 @@
 // 一轮完整探测：DoH 候选 + 内置池 -> 三关并发探测 -> 排名 -> 兜底轮
 import { resolveAll } from "./doh.js";
 import { probeIp, pool } from "./prober.js";
-import { rank, neededFallbacks } from "./ranker.js";
+import { rank, neededFallbacks, mergeSamples } from "./ranker.js";
 
 // 该域名该用哪些内置池。
 // 默认（未配 domainPools 或配了不存在的池名）用全部池 —— 保持「与域名无关地全量进候选」
@@ -59,8 +59,21 @@ export async function runProbe(cfg, log, onlyDomains = null) {
   const directFb = want ? [...want].filter((d) => fbDomains.includes(d) && !cfg.domains.includes(d)) : [];
 
   const resolved = await resolveCandidates(cfg, mainDomains, say);
-  const all = await pool(jobsOf(cfg, resolved), cfg.probe.concurrency);
-  const ranked = rank(all, cfg);
+  let all = await pool(jobsOf(cfg, resolved), cfg.probe.concurrency);
+  let ranked = rank(all, cfg);
+
+  // 复测抗抖动（0.3.0）：对每域名当前前 3 名各再采一枪，均值 + 失败罚分后重排名。
+  // 代价极小（≤24 个快候选、约 1~2s），换来「写进 hosts 的第一名是真的稳」——
+  // 单采样时同一 IP 相邻两轮分差可达数倍，排名近乎随机，而无谓的换 IP 要刷 DNS 缓存。
+  if ((cfg.probe.stableSamples ?? 2) >= 2) {
+    const jobs = [];
+    for (const [, rs] of ranked) {
+      for (const r of rs.slice(0, 3)) { jobs.push(() => probeIp(r.domain, r.ip, cfg)); }
+    }
+    const second = await pool(jobs, cfg.probe.concurrency);
+    all = mergeSamples(all, second);
+    ranked = rank(all, cfg);
+  }
 
   // 兜底轮：主域名全灭且配了替身 -> 探测替身域名
   const extra = new Map();

package/src/prober.js

@@ -4,6 +4,11 @@
 // 证书校验拦的是 DNS 污染，应用层终审拦的是共享 CDN 上未部署该域名的"假活"IP
 import tls from "node:tls";
 import https from "node:https";
+import net from "node:net";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFile } from "node:child_process";
 
 // 目标域名的应用层指纹：真实业务路径、必须包含的响应特征、允许状态码、拒绝特征、允许跳转的 host
 // 路径必须能代表真实业务；codeload 用归档下载路径，避免根路径 301 到 github.com 主站骗过校验
@@ -19,6 +24,15 @@ import https from "node:https";
 //    → 规则：**路径 `/` 只接受 200/3xx**。只有那些「根路径本来就不存在合法内容」的域名
 //    （objects 根路径是 Varnish 的 404、gist 是 301）才保留 4xx，且靠 reject 词表兜底。
 export const DOMAIN_SIG = {
+  // api.github.com：gh CLI / REST API 走它，DNS 同样被污染。判据用 /rate_limit：
+  // 未认证也返回 200，响应体是 JSON 且必含 "rate" 字段 —— 不依赖 GitHub 网页特征
+  "api.github.com": {
+    path: "/rate_limit",
+    mustContain: ["rate"],
+    allow: [200, 204],
+    reject: ["unknown domain", "Fastly error", "bad request"],
+    redirectHosts: [],
+  },
   "github.com": {
     path: "/",
     mustContain: ["github"],
@@ -27,6 +41,21 @@ export const DOMAIN_SIG = {
     reject: ["unknown domain", "Fastly error", "bad request"],
     redirectHosts: ["github.com"],
   },
+  // github.githubassets.com：github.com 网页的全部 JS/CSS/字体都从这里加载（0.3.0 新增）。
+  // 它不写进 hosts 时「页面能打开但样式全裂」，是直连浏览最常见的体验杀手。
+  // 判据用 favicon（2026-10-31 实测 4 个 Fastly .215 IP 全部 200 且以 `<svg` 开头）；
+  // 注意它的 Fastly 段是 185.199.108-111.**215**，与 githubusercontent 系的 .133 不同段
+  // （.133 对该 SNI 直接连接失败），所以 domainPools 走独立的 ghassets 池。
+  "github.githubassets.com": {
+    path: "/favicons/favicon.svg",
+    mustContain: ["<svg"],
+    allow: [200, 204],
+    reject: ["unknown domain", "Fastly error", "bad request"],
+    redirectHosts: [],
+  },
+  // ssh.github.com：SSH-over-443 端点（git clone git@ssh.github.com:... 用，0.3.0 新增）。
+  // type:"ssh" —— 不走 TLS/HTTP 三关，改探 SSH banner（见 sshProbe）。
+  "ssh.github.com": { type: "ssh" },
   "codeload.github.com": {
     path: "/torvalds/linux/tar.gz/refs/heads/master",
     mustContain: [],
@@ -45,7 +74,11 @@ export const DOMAIN_SIG = {
     redirectHosts: ["objects.githubusercontent.com"],
   },
   "raw.githubusercontent.com": {
-    path: "/torvalds/linux/README.md",
+    // 🔴 路径必须带分支段（2026-10-31 实测修正）：raw.githubusercontent.com 的第 2 段是
+    //    分支名，`/torvalds/linux/README.md` 会被当作「README.md 分支」返回 404 ——
+    //    就算网络全通也会被判死（假阴性）。正确形态 `/torvalds/linux/master/README`
+    //    实测 200 且响应体含 "Linux kernel"（linux 仓库根文件本来就叫 README，无 .md）。
+    path: "/torvalds/linux/master/README",
     mustContain: ["Linux kernel"],
     allow: [200, 204, 302, 303, 304, 307, 308],
     reject: ["unknown domain", "Fastly error", "bad request"],
@@ -65,6 +98,9 @@ export const DOMAIN_SIG = {
     reject: ["unknown domain", "Fastly error", "bad request"],
     redirectHosts: ["avatars.githubusercontent.com"],
   },
+  // cdn.jsdelivr.net：0.4.0 起已从默认兜底链移除（2026-10-31 实测 SNI 级硬封：
+  // node + 双 curl 共 45 次全部在 ClientHello 后被 RST，换 IP/换 TLS 栈均无效）。
+  // 判据保留在这里：老用户配置里若仍引用它，探测依然有正确的业务路径可用。
   "cdn.jsdelivr.net": {
     path: "/gh/torvalds/linux@master/README",
     mustContain: ["Linux kernel"],
@@ -90,12 +126,12 @@ function badRedirect(statusCode, location, sig) {
 //    十几条死候选就是几十秒 —— 池子因此不敢放宽，进而出现「明明有活 IP 却报 stuck」。
 //    这里先按 tcpMs 计，握手成功（connect 事件）后再把超时切到 tlsMs：
 //    快速淘汰死 IP，同时不误杀「连得上但 TLS 慢」的活 IP。
-function tcpTlsProbe(ip, domain, tcpMs, tlsMs) {
+function tcpTlsProbe(ip, domain, tcpMs, tlsMs, port = 443) {
   return new Promise((resolve) => {
     const t0 = Date.now();
     let tcpCost = -1;
     let stage = "tcp";
-    const sock = tls.connect({ host: ip, port: 443, servername: domain, rejectUnauthorized: true });
+    const sock = tls.connect({ host: ip, port, servername: domain, rejectUnauthorized: true });
     const done = (r) => { try { sock.destroy(); } catch { /* 已销毁 */ } resolve(r); };
     sock.setTimeout(tcpMs, () => done({ ok: false, stage, err: "timeout" }));
     sock.on("connect", () => { tcpCost = Date.now() - t0; stage = "tls"; sock.setTimeout(tlsMs); });
@@ -104,6 +140,102 @@ function tcpTlsProbe(ip, domain, tcpMs, tlsMs) {
   });
 }
 
+// SSH banner 探测（type:"ssh" 的域名走这条，如 ssh.github.com 的 SSH-over-443）：
+// 服务端**先**发 banner（SSH-2.0-...），客户端 TLS/HTTP 三关都不适用 —— 读到合法 banner 即活。
+// 超时复用 tcpMs：SSH banner 在 TCP 建连后立刻到，不需要单独一档。
+export function parseSshBanner(buf) {
+  const s = String(buf.slice(0, 255));
+  const nl = s.indexOf("\r\n");
+  if (nl === -1) { return null; }
+  const line = s.slice(0, nl);
+  return /^SSH-\d\.\d-.+\r?$/.test(line) ? line : "";
+}
+
+export function sshProbe(ip, tcpMs, port = 443) {
+  return new Promise((resolve) => {
+    const t0 = Date.now();
+    let tcpCost = -1;
+    let settled = false;
+    let acc = Buffer.alloc(0);
+    const sock = net.connect({ host: ip, port });
+    const done = (r) => {
+      if (settled) { return; }
+      settled = true;
+      try { sock.destroy(); } catch { /* 已销毁 */ }
+      resolve(r);
+    };
+    sock.setTimeout(tcpMs, () => done({ ok: false, stage: tcpCost < 0 ? "tcp" : "banner", err: "timeout" }));
+    sock.on("connect", () => { tcpCost = Date.now() - t0; });
+    sock.on("data", (c) => {
+      acc = Buffer.concat([acc, c]);
+      const banner = parseSshBanner(acc);
+      if (banner) { done({ ok: true, tcpMs: tcpCost, banner: banner.slice(0, 48), err: "" }); }
+      else if (banner === "") { done({ ok: false, stage: "banner", err: "not ssh" }); }
+      else if (acc.length >= 255) { done({ ok: false, stage: "banner", err: "not ssh" }); }
+    });
+    sock.on("timeout", () => done({ ok: false, stage: tcpCost < 0 ? "tcp" : "banner", err: "timeout" }));
+    sock.on("error", (e) => done({ ok: false, stage: tcpCost < 0 ? "tcp" : "banner", err: String(e.code || e.message).slice(0, 60) }));
+    sock.on("close", () => done({ ok: false, stage: tcpCost < 0 ? "tcp" : "banner", err: "closed" }));
+  });
+}
+
+// 🔴 schannel 二次探测：Node 的 TLS ClientHello 形态会被中间设备识别并 RST（README §3 实测：
+//    同一 IP 同一时刻 openssl 20/20、Node 5/20、浏览器正常）。Windows 10+ **自带**的
+//    curl.exe 是 Schannel 构建 —— 与 Edge 同一 TLS 栈，指纹与浏览器一致。
+//    被节点侧 TLS 阻断的候选用它重探一次：能给出「与浏览器一致」的真实判定，
+//    而不是把「浏览器明明能用」的域名写成 # blocked。
+// 🔴 必须显式定位 System32 的 curl.exe：PATH 里排在前面的可能是 Git 自带的 OpenSSL 构建
+//    （实测 mingw64 curl 走 OpenSSL，指纹又变回去了）。找不到就返回 null，退回旧行为。
+export function findSystemCurl() {
+  if (process.platform !== "win32") { return ""; }
+  const p = path.join(process.env.SystemRoot || "C:\\Windows", "System32", "curl.exe");
+  return fs.existsSync(p) ? p : "";
+}
+
+// 一次 schannel 探测：curl --resolve 把域名钉到候选 IP，-m 限时。
+// 返回 { ok, status, tlsMs, ttfb, err }；连接层失败（含 TLS 被 reset）status=-1。
+// opts = { exec, curl, port } 可注入（单测不打真网络）。
+export function curlSchannelProbe(ip, domain, cfg, opts = {}) {
+  const curl = opts.curl ?? findSystemCurl();
+  if (!curl) { return Promise.resolve(null); }
+  const exec = opts.exec || execFile;
+  const sig = sigFor(domain, cfg);
+  const httpMs = Math.max(2000, cfg.timeouts.httpMs);
+  const port = opts.port ?? 443;
+  return new Promise((resolve) => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "ghprobe-curl-"));
+    const body = path.join(dir, "body");
+    exec(curl, [
+      "-sS", "-o", body, "--resolve", `${domain}:${port}:${ip}`,
+      "-m", String(Math.round(httpMs / 1000)),
+      "-w", "%{http_code} %{time_appconnect} %{time_starttransfer}",
+      `https://${domain}:${port}${sig.path}`,
+    ], { timeout: httpMs + 4000, windowsHide: true }, (e, stdout, stderr) => {
+      let out = { ok: false, status: -1, tlsMs: -1, ttfb: -1, err: "" };
+      if (e) {
+        const msg = String(stderr || e.message).trim().split(/\r?\n/)[0].slice(0, 60);
+        out = { ok: false, status: -1, tlsMs: -1, ttfb: -1, err: `schannel:${msg || "failed"}` };
+      } else {
+        const parts = String(stdout).trim().split(/\s+/);
+        const statusCode = Number(parts[0]) || -1;
+        let bodyText = "";
+        try { bodyText = fs.readFileSync(body, "utf8").slice(0, 4096); } catch { /* 空响应体 */ }
+        const checked = checkHttpResponse(statusCode, bodyText, "", sig);
+        // 跳转校验弱化：curl 未跟随跳转、也没取回 Location 头，3xx 交给 allow 列表判。
+        // 只在 TLS 已经通过 schannel 之后才会走到这，风险可接受（README §3 的假活是 HTTP 层的）。
+        out = {
+          ok: checked.ok, status: statusCode,
+          tlsMs: Math.round(Number(parts[1]) * 1000) || -1,
+          ttfb: Math.round(Number(parts[2]) * 1000) || -1,
+          err: checked.ok ? "" : `http:${checked.err}`,
+        };
+      }
+      try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* 清理失败不管 */ }
+      resolve(out);
+    });
+  });
+}
+
 // 读取响应体前 n 字节，用于特征校验；读够后立即断开，不下载完整大页面
 function readPrefix(res, maxBytes) {  return new Promise((resolve) => {
     const chunks = [];
@@ -161,12 +293,12 @@ export function sigFor(domain, cfg) {
 }
 
 // 第三关：HTTP GET（host=IP、SNI=域名、Host头=域名），读少量响应体做终审
-function httpProbe(ip, domain, httpMs, cfg) {
+function httpProbe(ip, domain, httpMs, cfg, port = 443) {
   return new Promise((resolve) => {
     const sig = sigFor(domain, cfg);
     const t0 = Date.now();
     const req = https.request({
-      host: ip, servername: domain, method: "GET", path: sig.path, timeout: httpMs,
+      host: ip, port, servername: domain, method: "GET", path: sig.path, timeout: httpMs,
       headers: { Host: domain, "user-agent": "ghprobe/0.1.0", accept: "*/*" },
     }, async (res) => {
       const ttfb = Date.now() - t0;
@@ -198,15 +330,49 @@ export function looksLikeTlsBlocked(failure) {
   return RESET_RE.test(err) || err === "timeout";
 }
 
-// 探测单个 (域名, IP)：三关全过才算活；分数越小越优
-export async function probeIp(domain, ip, cfg) {
+// 探测单个 (域名, IP)：三关全过才算活；分数越小越优。
+// deps = { curlProbe, port } 可注入（单测把 port 指到本地服务，不打真网络），
+// 缺省 curlProbe 用 curlSchannelProbe、端口 443。
+// 两条扩展路径：
+//   ① type:"ssh" 的域名（ssh.github.com）不跑 TLS/HTTP 三关，读 SSH banner 判活；
+//   ② TLS 阶段被指纹阻断时（TCP 通、TLS 被 reset），用 Windows 自带 curl（schannel，
+//      与浏览器同一 TLS 栈）重探一次 —— 0.3.0 前这种情况只能写 # blocked 放弃，
+//      而「浏览器明明能用」的域名就这样被误判成不可达。重探也失败时：
+//      HTTP 层有响应 = TLS 其实通了（假活，不是指纹问题，不标 blocked）；
+//      连接层仍失败 = 连浏览器同款栈都过不去，才是真被阻断。
+export async function probeIp(domain, ip, cfg, deps = {}) {
   const { tlsMs, httpMs } = cfg.timeouts;
   const tcpMs = cfg.timeouts.tcpMs ?? tlsMs; // 老配置没这一项时退回 tlsMs，行为不变
-  const g = await tcpTlsProbe(ip, domain, tcpMs, tlsMs);
+  const port = deps.port ?? 443;
+  const sig = sigFor(domain, cfg);
+
+  if (sig.type === "ssh") {
+    const g = await sshProbe(ip, tcpMs, port);
+    return g.ok
+      ? { domain, ip, ok: true, tcpMs: g.tcpMs, tlsMs: g.tcpMs, ttfb: g.tcpMs, status: 0, score: g.tcpMs, banner: g.banner, err: "", via: "ssh" }
+      : { domain, ip, ok: false, stage: g.stage, err: g.err };
+  }
+
+  const g = await tcpTlsProbe(ip, domain, tcpMs, tlsMs, port);
   if (!g.ok) {
+    if (looksLikeTlsBlocked(g) && cfg.probe?.schannelRetry !== false) {
+      const s = await (deps.curlProbe || curlSchannelProbe)(ip, domain, cfg, { port });
+      if (s) {
+        if (s.ok) {
+          const tcp = g.tcpMs >= 0 ? g.tcpMs : s.tlsMs;
+          const tlsCost = s.tlsMs > 0 ? s.tlsMs : 0;
+          const score = Math.round(tcp * 0.4 + tlsCost * 0.4 + (s.ttfb > 0 ? s.ttfb : httpMs) * 0.2);
+          return {
+            domain, ip, ok: true, tcpMs: tcp, tlsMs: tcp + tlsCost,
+            ttfb: s.ttfb, status: s.status, score, via: "schannel", err: "",
+          };
+        }
+        return { domain, ip, ok: false, stage: s.status > 0 ? "http" : "tls", err: s.err, tlsBlocked: !(s.status > 0), via: "schannel" };
+      }
+    }
     return { domain, ip, ok: false, stage: g.stage, err: g.err, tlsBlocked: looksLikeTlsBlocked(g) };
   }
-  const h = await httpProbe(ip, domain, httpMs, cfg);
+  const h = await httpProbe(ip, domain, httpMs, cfg, port);
   const tlsCost = g.tlsMs - g.tcpMs;
   const score = Math.round(g.tcpMs * 0.4 + tlsCost * 0.4 + (h.ok ? h.ttfb : httpMs) * 0.2);
   return {

package/src/ranker.js

@@ -28,3 +28,29 @@ export function neededFallbacks(ranked, cfg) {
   }
   return [...new Set(list)];
 }
+
+// 多次采样合并（纯函数）：把首轮结果与复测样本按 (domain, ip) 分组，
+//   · 有活样本 -> score = 活样本均值 + 每个失败样本罚 penaltyMs（抖动 IP 别排第一）
+//   · 全部失败 -> 保留失败结果（字段取首个，ok=false，供 blockedDomainsFromRaw 判读）
+// 为什么需要：单次采样抖动大时排名近乎随机 —— 而每次换 IP 都要刷 DNS 缓存、断连接池，
+// 排名稳比单次「最优」更重要。0.3.0 前工具排名单采样，实测同一 IP 相邻两轮分差可达数倍。
+export function mergeSamples(first, extra, penaltyMs = 500) {
+  const by = new Map();
+  const push = (r) => {
+    if (!r || !r.domain || !r.ip) { return; }
+    const k = `${r.domain}|${r.ip}`;
+    if (!by.has(k)) { by.set(k, []); }
+    by.get(k).push(r);
+  };
+  for (const r of first) { push(r); }
+  for (const r of extra) { push(r); }
+  const out = [];
+  for (const rs of by.values()) {
+    const ok = rs.filter((r) => r.ok);
+    if (!ok.length) { out.push({ ...rs[0], ok: false }); continue; }
+    const failed = rs.length - ok.length;
+    const avg = Math.round(ok.reduce((a, r) => a + r.score, 0) / ok.length);
+    out.push({ ...ok[0], ok: true, score: avg + failed * penaltyMs, samples: rs.length });
+  }
+  return out;
+}

package/src/status.js

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// Copyright (C) 2026 zmw
+// status：秒级速查。与 doctor 的区别:doctor 跑一轮完整探测(~1 分钟)给诊断,
+// status **不打任何网络请求**,只把「hosts 里现在写了什么 / 自愈日志最近发生了什么 /
+// 计划任务在不在」摆出来 —— 日常「现在什么情况」用这个,坏了再上 doctor。
+import fs from "node:fs";
+import path from "node:path";
+import { parseBlock, targetDomains } from "./health.js";
+import { userDataDir, WIN_HOSTS } from "./hosts.js";
+import { readHeartbeat, heartbeatFresh, processAlive } from "./daemon.js";
+
+export function healthLogPath() {
+  return path.join(userDataDir(), "ghprobe.log");
+}
+
+// 读健康检查日志最后 n 行(文件不存在/读不了返回 [])
+export function readLogTail(n = 8, logPath = healthLogPath()) {
+  try {
+    const lines = fs.readFileSync(logPath, "utf8").trimEnd().split(/\r?\n/);
+    return lines.slice(-n);
+  } catch { return []; }
+}
+
+// 从 hosts 内容取块生成时间(# generated <ts> by ghprobe)，没有则 null
+function generatedAt(content) {
+  const m = String(content || "").match(/^# generated (\S+) by ghprobe$/m);
+  return m ? m[1] : null;
+}
+
+// 纯函数：由既有状态组装速查报告。全离线 —— 不探测、不解析、不查任务网络。
+export function buildStatusReport({ hostsContent = "", cfg, logTail = [], task = null, daemon = undefined }) {
+  const current = parseBlock(hostsContent);
+  const targets = targetDomains(cfg);
+  const lines = [];
+
+  // ① hosts 块现状
+  const gen = generatedAt(hostsContent);
+  if (!current.entries.size) {
+    lines.push("hosts：还没有 ghprobe 块 —— 先跑 ghprobe install");
+  } else {
+    lines.push(`hosts：${current.entries.size} 个域名（块生成于 ${gen ?? "?"}）`);
+    for (const [d, ip] of current.entries) {
+      const alts = (current.extras.get(d) || []).join(", ");
+      lines.push(`  ${d.padEnd(32)} ${ip}${alts ? `  备选: ${alts}` : ""}`);
+    }
+  }
+  const cooling = new Set([...current.absent.keys(), ...(current.blocked || new Map()).keys()]);
+  const missing = targets.filter((d) => !current.entries.has(d) && !cooling.has(d));
+  for (const [d, ts] of current.absent) { lines.push(`  [缺失] ${d}（${ts} 起冷却）`); }
+  for (const [d, ts] of (current.blocked || new Map())) { lines.push(`  [阻断] ${d}（${ts} 起冷却；浏览器栈也验证过被拦，详见 README §3）`); }
+  if (missing.length) { lines.push(`  [未写入] ${missing.join(", ")}（下轮健康检查自动补）`); }
+
+  // ② 常驻守护 + 计划任务
+  if (daemon === undefined) { daemon = readHeartbeat(); }
+  if (daemon && heartbeatFresh(daemon) && processAlive(daemon.pid)) {
+    const age = Math.round((Date.now() - new Date(daemon.at).getTime()) / 1000);
+    lines.push(`常驻守护：运行中（pid ${daemon.pid}，心跳 ${age}s 前，15~45s 自适应自愈）`);
+  } else if (daemon) {
+    lines.push("常驻守护：未运行（心跳陈旧）—— 监督者会在下一分钟自动拉起");
+  } else {
+    lines.push("常驻守护：未启动过 —— 下一轮 health（≤1 分钟）自动拉起");
+  }
+  if (task === null || task === undefined) {
+    lines.push("计划任务：查询跳过（仅 Windows）");
+  } else if (task.output && /ghprobe/i.test(task.output)) {
+    lines.push("计划任务：已注册，每分钟自愈中");
+  } else {
+    lines.push(`计划任务：${task.error ? `查询失败 ${task.error}` : "未注册 —— 跑 ghprobe install"}`);
+  }
+
+  // ③ 自愈日志尾部
+  if (logTail.length) {
+    lines.push(`自愈日志（最近 ${logTail.length} 条，完整见 ${healthLogPath()}）：`);
+    for (const l of logTail) { lines.push(`  ${l}`); }
+  } else {
+    lines.push("自愈日志：暂无（还没跑过 health，或日志不可读）");
+  }
+  return lines;
+}
+
+// 一轮速查。deps 全可注入（单测不打文件系统/任务）。
+export async function runStatus(cfg, deps = {}) {
+  const hostsContent = deps.hostsContent ?? (() => { try { return fs.readFileSync(WIN_HOSTS, "utf8"); } catch { return ""; } })();
+  const logTail = deps.logTail ?? readLogTail();
+  const task = deps.taskQuery ? await deps.taskQuery() : null;
+  const lines = buildStatusReport({ hostsContent, cfg, logTail, task });
+  return { lines, entries: parseBlock(hostsContent).entries.size };
+}