ghprobe 0.1.0 → 0.1.2

package/src/health.js

@@ -10,13 +10,17 @@ import { applyHosts, mergeHosts, WIN_HOSTS, acquireHostsLock, releaseHostsLock }
 const BEGIN = "# === ghprobe begin ===";
 const END = "# === ghprobe end ===";
 
-// 从 hosts 内容解析 ghprobe 块：有效 IP 映射、同名备选 IP、缺失域名冷却表
-// 块内行格式：`IP 域名`（同域名可多行：第一条 = 主 IP，其余 = 备选）或 `# absent 域名 时间戳`
+// 从 hosts 内容解析 ghprobe 块：有效 IP 映射、同名备选 IP、缺失域名冷却表、指纹阻断表
+// 块内行格式：
+//   `IP 域名`（同域名可多行：第一条 = 主 IP，其余 = 备选）
+//   `# absent 域名 时间戳`   —— 探测过、确实没有可用 IP
+//   `# blocked 域名 时间戳`  —— 探测不可判：TCP 连上了但 TLS 被本机指纹阻断（详见 prober.js）
 // 主 IP 进 entries（决策/探活只看它），备选进 extras（原样写回，供客户端 fallback）
 export function parseBlock(content) {
   const entries = new Map();
   const extras = new Map();
   const absent = new Map();
+  const blocked = new Map();
   let inBlock = false;
   for (const raw of String(content || "").split(/\r?\n/)) {
     const line = raw.trim();
@@ -24,8 +28,10 @@ export function parseBlock(content) {
     if (line.startsWith(END)) { inBlock = false; continue; }
     if (!inBlock) { continue; }
     if (line.startsWith("#")) {
-      const m = line.match(/^#\s+absent\s+(\S+)\s+(\S+)/);
-      if (m) { absent.set(m[1].toLowerCase(), m[2]); }
+      const ma = line.match(/^#\s+absent\s+(\S+)\s+(\S+)/);
+      if (ma) { absent.set(ma[1].toLowerCase(), ma[2]); continue; }
+      const mb = line.match(/^#\s+blocked\s+(\S+)\s+(\S+)/);
+      if (mb) { blocked.set(mb[1].toLowerCase(), mb[2]); }
       continue;
     }
     const parts = line.split(/\s+/);
@@ -38,12 +44,12 @@ export function parseBlock(content) {
       if (!list.includes(ip)) { list.push(ip); extras.set(domain, list); }
     }
   }
-  return { entries, extras, absent };
+  return { entries, extras, absent, blocked };
 }
 
-// 生成健康检查用的 hosts 块：有效条目（每域名 主 IP + 备选）+ 缺失域名冷却注释
+// 生成健康检查用的 hosts 块：有效条目（每域名 主 IP + 备选）+ 缺失域名冷却注释 + 指纹阻断注释
 // extras：domain -> [备选 IP...]。同域名多行让客户端在首个 IP 抖动时可自动 fallback。
-export function buildHealthBlock(entries, absent, extras = new Map()) {
+export function buildHealthBlock(entries, absent, extras = new Map(), blocked = new Map()) {
   const lines = [BEGIN, `# generated ${new Date().toISOString()} by ghprobe`];
   for (const [domain, ip] of entries) {
     lines.push(`${ip} ${domain}`);
@@ -52,6 +58,7 @@ export function buildHealthBlock(entries, absent, extras = new Map()) {
     }
   }
   for (const [domain, ts] of absent) { lines.push(`# absent ${domain} ${ts}`); }
+  for (const [domain, ts] of blocked) { lines.push(`# blocked ${domain} ${ts}`); }
   lines.push(END);
   return lines.join("\n");
 }
@@ -78,9 +85,15 @@ export function blockFromProbeResult(cfg, r) {
   for (const [d, rs] of r.ranked || []) { put(d, rs); }
   for (const [d, rs] of r.extra || []) { put(d, rs); }
   const absent = new Map();
+  const blocked = new Map();
+  const tlsBlocked = blockedDomainsFromRaw(r.raw);
   const now = new Date().toISOString();
-  for (const d of targetDomains(cfg)) { if (!entries.has(d)) { absent.set(d, now); } }
-  return buildHealthBlock(entries, absent, extras);
+  for (const d of targetDomains(cfg)) {
+    if (entries.has(d)) { continue; }
+    // 与 health 路径保持同构：指纹阻断写 `# blocked`，确实无可用 IP 写 `# absent`
+    if (tlsBlocked.has(d)) { blocked.set(d, now); } else { absent.set(d, now); }
+  }
+  return buildHealthBlock(entries, absent, extras, blocked);
 }
 
 // 全灭护栏（写入前判定）：新块一条有效 IP 都没有、而 hosts 里还有旧条目时，必须拒绝写入 ——
@@ -89,11 +102,33 @@ export function shouldKeepOldBlock(oldContent, newBlock) {
   return parseBlock(newBlock).entries.size === 0 && parseBlock(oldContent).entries.size > 0;
 }
 
-// 决策（纯函数）：输入已写入 IP 的探活结果 + 当前块状态，输出动作
+// 决策（纯函数）：输入「已写入条目的探活结果」+ 当前块状态，输出动作
 // 横向判据：严格多数条目同时失败视为网络故障（本轮不动，避开黑洞窗口）；
 // 单条目失败或缺失域名（非冷却）才触发全量重排
+//
+// 🔴 2026-10-11 两个关键修正：
+//   ① 探活结果现在**同时包含主条目与备选条目**（每条带 role: "main" / "alt"）。
+//      一个域名只有「它所有已写入条目全部失败」才算挂 —— 备选还活着时不该重排。
+//   ② 主挂了、备选活着 → **把备选提上来（promote）**，不重排。
+//      这条是针对实测故障的：主 IP 变成假活（返回 400）而备选是好的，旧逻辑不知道备选存在，
+//      直接去重排 → 撞上 IP 抖动窗口 → 换了个更差的，用户反而断网。
+//      备选本来就是为了这一刻存在的，不该只写不读。
 export function decide(probeResults, current, cfg) {
-  const failed = new Set(probeResults.filter((r) => !r.ok).map((r) => r.domain));
+  // 按域名聚合：只有全部条目都失败才算这个域名挂了
+  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 failed = new Set();
+  const promote = new Map();
+  for (const [d, rs] of byDomain) {
+    const alive = rs.filter((r) => r.ok);
+    if (alive.length === 0) { failed.add(d); continue; }
+    // 主条目失败但有备选活着 -> 提升备选（不重排）
+    const main = rs.find((r) => r.role !== "alt");
+    if (main && !main.ok) { promote.set(d, alive[0].ip); }
+  }
   const total = current.entries.size;
 
   // 只有「已写入条目全部失败」才可能是网络级故障（黑洞窗口），此时本轮不动、避开窗口。
@@ -101,7 +136,7 @@ export function decide(probeResults, current, cfg) {
   // 🔴 旧判据 `failed.size * 2 > total`（多数失败即放弃）已证实会误触发：分母只数已写入
   //    条目、常低到 3~4，实测「3 条陈旧 + 1 条健康」被误判成断网 → 该修的时候不修。
   if (total >= 2 && failed.size === total) {
-    return { action: "none", reason: "全部已写入 IP 同时失败，疑似网络故障" };
+    return { action: "none", reason: "全部已写入 IP 同时失败，疑似网络故障", promote: new Map() };
   }
 
   const cooldownMs = (cfg.schedule?.absentCooldownHours ?? 1) * 3600_000;
@@ -110,7 +145,9 @@ export function decide(probeResults, current, cfg) {
   const missing = new Set();
   for (const d of targets) {
     if (current.entries.has(d)) { continue; }
-    const ts = current.absent.get(d);
+    // `# absent`（确实无可用 IP）与 `# blocked`（探测不可判：本机 TLS 指纹被阻断）
+    // 共用同一档冷却 —— 两者都不该每分钟重探一遍
+    const ts = current.absent.get(d) || current.blocked?.get(d);
     if (ts && now - new Date(ts).getTime() < cooldownMs) { continue; }
     missing.add(d);
   }
@@ -118,33 +155,80 @@ export function decide(probeResults, current, cfg) {
   const orphan = [...current.entries.keys()].filter((d) => !targets.includes(d));
 
   const diagnose = [...new Set([...failed, ...missing, ...orphan])];
-  if (diagnose.length === 0) { return { action: "none", reason: "全部健康" }; }
-  return { action: "full", domains: diagnose, reason: `需重排: ${diagnose.join(", ")}` };
+  if (diagnose.length === 0 && promote.size === 0) {
+    return { action: "none", reason: "全部健康", promote: new Map() };
+  }
+  if (diagnose.length === 0) {
+    return { action: "full", domains: [], promote, reason: `主 IP 失效，提上备选: ${[...promote.keys()].join(", ")}` };
+  }
+  return { action: "full", domains: diagnose, promote, reason: `需重排: ${diagnose.join(", ")}` };
 }
 
 // 部分更新（纯函数）：只改 diagnose 域名；全灭护栏保证不把好 IP 写成空
 // 返回的新 entries/absent 用于与当前对比，changed 记录真正换掉 IP 的域名
 // stuck：被诊断了、但本轮一个活 IP 都没找到、只能保留旧值的域名（黑洞窗口里必然出现，
 //        显式报出来，否则日志只写「无变化」会让人以为工具没干活）
-export function applyDelta(current, ranked, extra, diagnose, cfg) {
+// 从一轮原始探测结果里挑出「指纹被阻断」的域名：
+// 该域名所有候选都失败了，且**失败全部发生在 TLS 阶段（TCP 已连上）** —— 见 prober.js 的说明。
+// 只有全部失败都是这一类才判定，避免把「一半 IP 黑洞 + 一半被 reset」误当成指纹阻断。
+export function blockedDomainsFromRaw(raw) {
+  const by = new Map();
+  for (const r of raw || []) {
+    if (!by.has(r.domain)) { by.set(r.domain, { total: 0, alive: 0, blocked: 0 }); }
+    const e = by.get(r.domain);
+    e.total++;
+    if (r.ok) { e.alive++; } else if (r.tlsBlocked) { e.blocked++; }
+  }
+  const out = new Set();
+  for (const [d, e] of by) {
+    if (e.alive === 0 && e.blocked > 0 && e.blocked === e.total) { out.add(d); }
+  }
+  return out;
+}
+
+export function applyDelta(current, ranked, extra, diagnose, cfg, promote = new Map(), tlsBlocked = new Set()) {
   const entries = new Map(current.entries);
   const extras = new Map(current.extras || []);
   const absent = new Map(current.absent);
+  const blocked = new Map(current.blocked || []);
   const changed = [];
   const now = new Date().toISOString();
   const allResult = new Map([...ranked, ...extra]);
   const maxPer = Math.max(1, cfg.hosts?.maxEntriesPerDomain ?? 2);
 
+  // 0) 提升：主 IP 失效、备选还活着 -> 备选上位，旧主降为备选。
+  //    旧主留着当兜底 —— GitHub 的 IP 是分钟级抖动，它可能下一分钟就活了。
+  for (const [d, ip] of promote) {
+    const oldMain = entries.get(d);
+    const alts = (extras.get(d) || []).filter((x) => x !== ip);
+    if (oldMain && oldMain !== ip && !alts.includes(oldMain)) { alts.unshift(oldMain); }
+    entries.set(d, ip);
+    const kept = alts.slice(0, maxPer - 1);
+    if (kept.length) { extras.set(d, kept); } else { extras.delete(d); }
+    absent.delete(d);
+    changed.push(d);
+  }
+
   for (const d of diagnose) {
     const list = allResult.get(d) || [];
     const best = list[0];
     if (best) {
       if (entries.get(d) !== best.ip) { entries.set(d, best.ip); changed.push(d); }
-      const alt = list.slice(1, maxPer).map((x) => x.ip);
-      if (alt.length) { extras.set(d, alt); } else { extras.delete(d); }
+      // 🔴 备选是「合并」而不是「覆盖」：本轮只探到 1 个活 IP 时，把原有备选保留下来。
+      //    旧写法 `alt.length ? set : delete` 会在抖动窗口里（活 IP 少）顺手删掉备选 ——
+      //    恰恰在最需要 fallback 的时候把兜底丢了。新的排前、旧的排后，超出 maxPer 截断。
+      const freshAlt = list.slice(1, maxPer).map((x) => x.ip);
+      const oldAlt = (extras.get(d) || []).filter((x) => x !== best.ip);
+      const merged = [...new Set([...freshAlt, ...oldAlt])].slice(0, maxPer - 1);
+      if (merged.length) { extras.set(d, merged); } else { extras.delete(d); }
       absent.delete(d);
+      blocked.delete(d);
     } else if (!entries.has(d)) {
-      absent.set(d, now);
+      // 🔴 指纹被阻断 ≠ 不可达：不写 absent，写 blocked。
+      //    两者共用同一档冷却（decide 里查），但语义不同 —— blocked 表示
+      //    「本机探测客户端（Node）的 TLS 指纹被识别，用户的浏览器很可能照样能访问」，
+      //    写 absent 会让工具主动放弃一个其实可用的域名，日志也会误导。
+      if (tlsBlocked.has(d)) { blocked.set(d, now); } else { absent.set(d, now); }
     }
   }
 
@@ -158,7 +242,9 @@ export function applyDelta(current, ranked, extra, diagnose, cfg) {
   }
   // orphan 已在上一步删掉，这里只剩「配置内、诊断过、却没探到活 IP、于是保留旧值」的域名
   const stuck = diagnose.filter((d) => allow.has(d) && entries.has(d) && !(allResult.get(d) || []).length);
-  return { entries, extras, absent, changed, stuck };
+  // 指纹被阻断的域名（没有写进 entries，也不是 absent）
+  const sniBlocked = diagnose.filter((d) => allow.has(d) && !entries.has(d) && tlsBlocked.has(d));
+  return { entries, extras, absent, blocked, changed, stuck, sniBlocked };
 }
 
 function sameMap(a, b) {
@@ -190,10 +276,18 @@ export async function runHealth(cfg, log, write = false, hostsPath = WIN_HOSTS)
     return fullUpdate(cfg, log, content, current, targetDomains(cfg), write, hostsPath);
   }
 
-  const jobs = [...current.entries].map(([d, ip]) => () => probeIp(d, ip, cfg));
-  const probeResults = await pool(jobs, cfg.probe.concurrency);
+  // 🔴 主条目 + 备选条目一起探活。旧版只探主条目 —— 于是「主 IP 挂了、备选还是好的」
+  //    这种最常见的情况工具根本不知道，直接去重排（撞抖动窗口），而它本来只需把备选提上来。
+  const pairs = [];
+  for (const [d, ip] of current.entries) {
+    pairs.push([d, ip, "main"]);
+    for (const alt of current.extras.get(d) || []) { pairs.push([d, alt, "alt"]); }
+  }
+  const jobs = pairs.map(([d, ip]) => () => probeIp(d, ip, cfg));
+  const probed = await pool(jobs, cfg.probe.concurrency);
+  const probeResults = probed.map((r, i) => ({ ...r, role: pairs[i][2] }));
   for (const r of probeResults) {
-    say(`${r.ok ? "[OK ]" : "[FAIL]"} ${r.domain} @ ${r.ip} err=${r.err}`);
+    say(`${r.ok ? "[OK ]" : "[FAIL]"}${r.role === "alt" ? " ALT" : "    "} ${r.domain} @ ${r.ip} err=${r.err}`);
   }
 
   const decision = decide(probeResults, current, cfg);
@@ -203,28 +297,40 @@ export async function runHealth(cfg, log, write = false, hostsPath = WIN_HOSTS)
   }
 
   say(`异常：${decision.reason}`);
-  return fullUpdate(cfg, log, content, current, decision.domains, write, hostsPath);
+  return fullUpdate(cfg, log, content, current, decision.domains, write, hostsPath, decision.promote);
 }
 
 // 全量探测 + 部分更新 + 写回；护栏与粘性都在 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) {
+async function fullUpdate(cfg, log, content, current, diagnose, write, hostsPath = WIN_HOSTS, promote = new Map()) {
   const say = log || (() => {});
-  const r = await runProbe(cfg, log, diagnose);
-  const d = applyDelta(current, r.ranked, r.extra, diagnose, cfg);
+  // diagnose 为空 = 只有「提上备选」要做，没有需要重排的域名 -> 跳过探测，直接写提升结果
+  const r = diagnose.length ? await runProbe(cfg, log, diagnose) : { ranked: new Map(), extra: new Map(), raw: [] };
+  const tlsBlocked = blockedDomainsFromRaw(r.raw);
+  const d = applyDelta(current, r.ranked, r.extra, diagnose, cfg, promote, tlsBlocked);
 
   const entriesChanged = !sameMap(d.entries, current.entries);
   const absentChanged = !sameMap(d.absent, current.absent);
+  const blockedChanged = !sameMap(d.blocked, current.blocked || new Map());
   const extrasChanged = !sameExtras(d.extras, current.extras || new Map());
   const stuckNote = d.stuck.length ? `；无可用 IP 保留原值: ${d.stuck.join(", ")}` : "";
-  if (!entriesChanged && !absentChanged && !extrasChanged) {
-    say(`探测无变化，保持现状（护栏/粘性生效）${stuckNote}`);
-    return { action: "none", reason: `无变化${stuckNote}`, block: null, stuck: d.stuck };
+  const blockedNote = d.sniBlocked.length
+    ? `；探测不可判（本机 TLS 指纹被阻断，浏览器可能仍可用）: ${d.sniBlocked.join(", ")}` : "";
+  if (!entriesChanged && !absentChanged && !blockedChanged && !extrasChanged) {
+    say(`探测无变化，保持现状（护栏/粘性生效）${stuckNote}${blockedNote}`);
+    return { action: "none", reason: `无变化${stuckNote}${blockedNote}`, block: null, stuck: d.stuck };
   }
 
-  const block = buildHealthBlock(d.entries, d.absent, d.extras);
-  const msg = d.changed.length ? `更新域名: ${d.changed.join(", ")}` : "更新缺失域名冷却记录";
+  const block = buildHealthBlock(d.entries, d.absent, d.extras, d.blocked);
+  // 日志里把「提上备选」和「重排换 IP」分开写，否则看日志分不清是哪种动作
+  const promoted = [...promote.keys()];
+  const reranked = d.changed.filter((x) => !promote.has(x));
+  const parts = [];
+  if (promoted.length) { parts.push(`提上备选: ${promoted.join(", ")}`); }
+  if (reranked.length) { parts.push(`重排换 IP: ${reranked.join(", ")}`); }
+  if (d.sniBlocked.length) { parts.push(`指纹阻断: ${d.sniBlocked.join(", ")}`); }
+  const msg = parts.length ? parts.join("；") : "更新缺失域名冷却记录";
   if (write) {
     const lock = acquireHostsLock();
     if (!lock) {

package/src/prober.js

@@ -7,54 +7,69 @@ import https from "node:https";
 
 // 目标域名的应用层指纹：真实业务路径、必须包含的响应特征、允许状态码、拒绝特征、允许跳转的 host
 // 路径必须能代表真实业务；codeload 用归档下载路径，避免根路径 301 到 github.com 主站骗过校验
+//
+// 🔴 状态码白名单的取舍（2026-10-11 实测踩坑）：
+//    白名单里放 4xx 等于给「不服务该域名的假活 IP」发通行证 —— 它们 TCP/TLS 都通、
+//    证书也合法（同属 GitHub 的 CDN），但 HTTP 层对所有路径回 4xx。实测
+//    `20.205.243.161` 对 github.com 的 `/`、`/login` 全回 **400**，响应体还是
+//    **GitHub 自己的错误页**（`<title>Bad request &middot; GitHub</title>`）——
+//    于是 `mustContain:["github"]` 也命中，三道判据全部放行，该 IP 被排到第 1 名写进 hosts，
+//    用户拿到 400。更糟的是「同名多条目 fallback」兜不住它：**400 是合法 HTTP 响应，
+//    不是连接失败，客户端不会回退到备选**。
+//    → 规则：**路径 `/` 只接受 200/3xx**。只有那些「根路径本来就不存在合法内容」的域名
+//    （objects 根路径是 Varnish 的 404、gist 是 301）才保留 4xx，且靠 reject 词表兜底。
 export const DOMAIN_SIG = {
   "github.com": {
     path: "/",
     mustContain: ["github"],
-    allow: [200, 204, 301, 302, 303, 304, 307, 308, 400, 401, 403, 404],
-    reject: ["unknown domain", "Fastly error"],
+    // 只留 2xx/3xx：根路径必须真的返回 GitHub 首页（或跳转到 github.com）
+    allow: [200, 204, 301, 302, 303, 304, 307, 308],
+    reject: ["unknown domain", "Fastly error", "bad request"],
     redirectHosts: ["github.com"],
   },
   "codeload.github.com": {
     path: "/torvalds/linux/tar.gz/refs/heads/master",
     mustContain: [],
     allow: [200, 204, 302, 303, 304, 307, 308],
-    reject: ["unknown domain", "Fastly error"],
+    reject: ["unknown domain", "Fastly error", "bad request"],
     redirectHosts: ["codeload.github.com", "objects.githubusercontent.com"],
   },
   "objects.githubusercontent.com": {
+    // ⚠️ 根路径必然 404（实测 Varnish 返回纯 "404 Not Found"，响应体里没有 "github"），
+    //    所以这里无法用 mustContain 兜底，4xx 必须留在白名单里 —— 是已知的判据弱点，
+    //    实际靠 reject 词表（unknown domain / Fastly error）拦假活节点。
     path: "/",
     mustContain: [],
     allow: [200, 204, 302, 303, 304, 307, 308, 400, 401, 403, 404],
-    reject: ["unknown domain", "Fastly error"],
+    reject: ["unknown domain", "Fastly error", "bad request"],
     redirectHosts: ["objects.githubusercontent.com"],
   },
   "raw.githubusercontent.com": {
     path: "/torvalds/linux/README.md",
     mustContain: ["Linux kernel"],
     allow: [200, 204, 302, 303, 304, 307, 308],
-    reject: ["unknown domain", "Fastly error"],
+    reject: ["unknown domain", "Fastly error", "bad request"],
     redirectHosts: ["raw.githubusercontent.com", "objects.githubusercontent.com"],
   },
   "gist.githubusercontent.com": {
     path: "/",
     mustContain: [],
     allow: [200, 204, 301, 302, 303, 304, 307, 308, 400, 401, 403, 404],
-    reject: ["unknown domain", "Fastly error"],
+    reject: ["unknown domain", "Fastly error", "bad request"],
     redirectHosts: ["gist.githubusercontent.com", "gist.github.com"],
   },
   "avatars.githubusercontent.com": {
     path: "/u/1?v=4",
     mustContain: [],
     allow: [200, 204, 302, 303, 304, 307, 308],
-    reject: ["unknown domain", "Fastly error"],
+    reject: ["unknown domain", "Fastly error", "bad request"],
     redirectHosts: ["avatars.githubusercontent.com"],
   },
   "cdn.jsdelivr.net": {
     path: "/gh/torvalds/linux@master/README",
     mustContain: ["Linux kernel"],
     allow: [200, 204, 301, 302, 303, 304, 307, 308],
-    reject: ["unknown domain", "Fastly error"],
+    reject: ["unknown domain", "Fastly error", "bad request"],
     redirectHosts: ["cdn.jsdelivr.net", "www.jsdelivr.com", "jsdelivr.net"],
   },
 };
@@ -90,8 +105,7 @@ function tcpTlsProbe(ip, domain, tcpMs, tlsMs) {
 }
 
 // 读取响应体前 n 字节，用于特征校验；读够后立即断开，不下载完整大页面
-function readPrefix(res, maxBytes) {
-  return new Promise((resolve) => {
+function readPrefix(res, maxBytes) {  return new Promise((resolve) => {
     const chunks = [];
     let got = 0;
     let settled = false;
@@ -126,10 +140,30 @@ export function checkHttpResponse(statusCode, body, location, sig) {
   return { ok: false, err: `status:${statusCode}` };
 }
 
+// 未在 DOMAIN_SIG 里声明、也没有配置判据时的兜底判据
+const DEFAULT_SIG = {
+  path: "/",
+  mustContain: [],
+  allow: [200, 204, 301, 302, 303, 304, 307, 308],
+  reject: ["unknown domain", "Fastly error", "bad request"],
+  redirectHosts: [],
+};
+
+// 取某域名的探测判据：**配置里 fallbackSigs 声明的优先于代码里的 DOMAIN_SIG**。
+// 🔴 为什么替身域名必须能自带判据：不同替身服务的 URL 形态不同 ——
+//    CDN 映射是 `/gh/<user>/<repo>@<ref>/<path>`，代理是 `/<完整原始 URL>` ——
+//    判据没法写死在代码里，用户新增一个替身也不该被要求改源码。
+export function sigFor(domain, cfg) {
+  const override = cfg?.fallbackSigs?.[domain];
+  const base = DOMAIN_SIG[domain];
+  if (!base && !override) { return DEFAULT_SIG; }
+  return { ...DEFAULT_SIG, ...(base || {}), ...(override || {}) };
+}
+
 // 第三关：HTTP GET（host=IP、SNI=域名、Host头=域名），读少量响应体做终审
-function httpProbe(ip, domain, httpMs) {
+function httpProbe(ip, domain, httpMs, cfg) {
   return new Promise((resolve) => {
-    const sig = DOMAIN_SIG[domain] || { path: "/", mustContain: [], allow: [200, 204, 301, 302, 303, 304, 307, 308, 400, 401, 403, 404], reject: ["unknown domain", "Fastly error"], redirectHosts: [] };
+    const sig = sigFor(domain, cfg);
     const t0 = Date.now();
     const req = https.request({
       host: ip, servername: domain, method: "GET", path: sig.path, timeout: httpMs,
@@ -146,13 +180,33 @@ function httpProbe(ip, domain, httpMs) {
   });
 }
 
+// 🔴 区分两类失败（2026-10-11 实测）：
+//   ① stage=tcp  —— TCP 握手就没成功（超时 / 拒绝）-> 这个 IP 确实不可用
+//   ② stage=tls  —— **TCP 连上了，但 TLS 阶段被重置或永远不完成** -> 很可能不是 IP 的问题，
+//      而是本机 TLS 指纹被中间设备识别后掐断（DPI 按 ClientHello 的形态放行/拦截）。
+//
+//   为什么必须区分：实测同一 IP、同一 SNI、同一时刻 ——
+//     openssl s_client 20/20 握手成功，node tls.connect 5/20，curl 3/20；
+//     而浏览器（Edge）能正常打开同一个 URL。
+//   ghprobe 自己就是 Node，**它的探测客户端指纹和用户的浏览器不同** ——
+//   把 ② 判成「IP 不可用」会把「浏览器其实能用」的域名误记成不可达（假阴性），
+//   还会写进 `# absent` 冷却让工具主动放弃它。
+const RESET_RE = /ECONNRESET|EPIPE|ECONNABORTED|socket hang up|Client network socket disconnected/i;
+export function looksLikeTlsBlocked(failure) {
+  if (!failure || failure.ok || failure.stage !== "tls") { return false; }
+  const err = String(failure.err || "");
+  return RESET_RE.test(err) || err === "timeout";
+}
+
 // 探测单个 (域名, IP)：三关全过才算活；分数越小越优
 export async function probeIp(domain, ip, cfg) {
   const { tlsMs, httpMs } = cfg.timeouts;
   const tcpMs = cfg.timeouts.tcpMs ?? tlsMs; // 老配置没这一项时退回 tlsMs，行为不变
   const g = await tcpTlsProbe(ip, domain, tcpMs, tlsMs);
-  if (!g.ok) { return { domain, ip, ok: false, stage: g.stage, err: g.err }; }
-  const h = await httpProbe(ip, domain, httpMs);
+  if (!g.ok) {
+    return { domain, ip, ok: false, stage: g.stage, err: g.err, tlsBlocked: looksLikeTlsBlocked(g) };
+  }
+  const h = await httpProbe(ip, domain, httpMs, cfg);
   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 {