ghprobe 0.0.0-stage → 0.1.0

package/src/doh.js

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// Copyright (C) 2026 zmw
+// DoH 联邦解析：RFC 8484 wire format，端点 IP 直连，无任何 UDP53 路径
+import https from "node:https";
+
+// 构造最小 DNS A 查询报文：header(12) + QNAME 标签串 + 根0 + QTYPE=A + QCLASS=IN
+export function buildQuery(id, name) {
+  if (id < 0 || id > 65535) { throw new Error("dns id out of range"); }
+  const hdr = Buffer.alloc(12);
+  hdr.writeUInt16BE(id, 0);
+  hdr.writeUInt16BE(0x0100, 2); // RD=1
+  hdr.writeUInt16BE(1, 4); // QDCOUNT=1
+  const labels = [];
+  for (const label of String(name).split(".")) {
+    if (!label.length || label.length > 63) { throw new Error(`bad label: ${label}`); }
+    labels.push(Buffer.from([label.length]), Buffer.from(label));
+  }
+  return Buffer.concat([hdr, ...labels, Buffer.from([0, 0, 1, 0, 1])]);
+}
+
+// 解析应答中的 A 记录；名字支持压缩指针，解析失败不抛错只返回已得结果
+export function parseA(buf) {
+  const ips = [];
+  if (!buf || buf.length < 12) { return ips; }
+  const qd = buf.readUInt16BE(4);
+  const an = buf.readUInt16BE(6);
+  let off = 12;
+  const skipName = () => {
+    for (;;) {
+      if (off >= buf.length) { return; }
+      const len = buf[off];
+      if (len === 0) { off += 1; return; }
+      if ((len & 0xc0) === 0xc0) { off += 2; return; }
+      off += len + 1;
+    }
+  };
+  for (let i = 0; i < qd; i++) { skipName(); off += 4; }
+  for (let i = 0; i < an && off + 10 <= buf.length; i++) {
+    skipName();
+    if (off + 10 > buf.length) { break; }
+    const type = buf.readUInt16BE(off);
+    const rdlen = buf.readUInt16BE(off + 8);
+    if (type === 1 && rdlen === 4 && off + 14 <= buf.length) {
+      ips.push(`${buf[off + 10]}.${buf[off + 11]}.${buf[off + 12]}.${buf[off + 13]}`);
+    }
+    off += 10 + rdlen;
+  }
+  return ips;
+}
+
+// 单端点 DoH 查询：POST wire 报文，IP 直连 + 可选 SNI 覆盖（证书仍按 servername 校验）
+// 应答只校验 query ID 是否与请求一致，不单独解析 question 段：端点是我们主动 TLS 直连的已知服务器，
+// 信道经过证书校验，且 ID 已匹配，足以排除响应错位与缓存投毒；question 段校验属防御性冗余，不做
+export function queryDoh(ep, name, timeoutMs) {
+  return new Promise((resolve) => {
+    const t0 = Date.now();
+    const qid = (Math.random() * 65536) | 0;
+    const qbuf = buildQuery(qid, name);
+    const req = https.request({
+      host: ep.host, path: ep.path || "/dns-query",
+      method: "POST", timeout: timeoutMs,
+      headers: { "content-type": "application/dns-message" },
+      // 只在显式配了 sni 时覆盖；否则交给 node 按 host 自动推导（IP 不允许当 SNI）
+      ...(ep.sni ? { servername: ep.sni } : {}),
+    }, (res) => {
+      const chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("end", () => {
+        const body = Buffer.concat(chunks);
+        if (body.length < 12) { resolve({ ep, ok: false, ms: Date.now() - t0, ips: [], err: "short response" }); return; }
+        const rid = body.readUInt16BE(0);
+        if (rid !== qid) { resolve({ ep, ok: false, ms: Date.now() - t0, ips: [], err: `id mismatch ${rid}!==${qid}` }); return; }
+        const rcode = body[3] & 0x0f;
+        resolve({ ep, ok: res.statusCode === 200 && rcode === 0, ms: Date.now() - t0, ips: rcode === 0 ? parseA(body) : [], err: res.statusCode !== 200 ? `http ${res.statusCode}` : `rcode ${rcode}` });
+      });
+    });
+    req.on("timeout", () => { req.destroy(); resolve({ ep, ok: false, ms: Date.now() - t0, ips: [], err: "timeout" }); });
+    req.on("error", (e) => resolve({ ep, ok: false, ms: Date.now() - t0, ips: [], err: String(e.code || e.message).slice(0, 60) }));
+    req.end(qbuf);
+  });
+}
+
+// 联邦查询：全部端点并发，成功者取并集去重
+export async function resolveAll(endpoints, name, timeoutMs) {
+  const rs = await Promise.all(endpoints.map((ep) => queryDoh(ep, name, timeoutMs)));
+  const ips = new Set();
+  for (const r of rs) { for (const ip of r.ips) { ips.add(ip); } }
+  return { ips: [...ips], sources: rs };
+}

package/src/health.js

@@ -0,0 +1,244 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// Copyright (C) 2026 zmw
+// 调度层：健康检查（哨兵）+ 决策 + 部分更新 + 全灭护栏
+// 无状态文件：缺失域名冷却表直接编码进 hosts 块注释，跨进程、跨重启不丢
+import fs from "node:fs";
+import { probeIp, pool } from "./prober.js";
+import { runProbe } from "./probe.js";
+import { applyHosts, mergeHosts, WIN_HOSTS, acquireHostsLock, releaseHostsLock } from "./hosts.js";
+
+const BEGIN = "# === ghprobe begin ===";
+const END = "# === ghprobe end ===";
+
+// 从 hosts 内容解析 ghprobe 块：有效 IP 映射、同名备选 IP、缺失域名冷却表
+// 块内行格式：`IP 域名`（同域名可多行：第一条 = 主 IP，其余 = 备选）或 `# absent 域名 时间戳`
+// 主 IP 进 entries（决策/探活只看它），备选进 extras（原样写回，供客户端 fallback）
+export function parseBlock(content) {
+  const entries = new Map();
+  const extras = new Map();
+  const absent = new Map();
+  let inBlock = false;
+  for (const raw of String(content || "").split(/\r?\n/)) {
+    const line = raw.trim();
+    if (line.startsWith(BEGIN)) { inBlock = true; continue; }
+    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]); }
+      continue;
+    }
+    const parts = line.split(/\s+/);
+    if (parts.length >= 2 && parts[0] && parts[1]) {
+      const domain = parts[1].toLowerCase();
+      const ip = parts[0];
+      if (!entries.has(domain)) { entries.set(domain, ip); continue; }
+      if (entries.get(domain) === ip) { continue; }
+      const list = extras.get(domain) || [];
+      if (!list.includes(ip)) { list.push(ip); extras.set(domain, list); }
+    }
+  }
+  return { entries, extras, absent };
+}
+
+// 生成健康检查用的 hosts 块：有效条目（每域名 主 IP + 备选）+ 缺失域名冷却注释
+// extras：domain -> [备选 IP...]。同域名多行让客户端在首个 IP 抖动时可自动 fallback。
+export function buildHealthBlock(entries, absent, extras = new Map()) {
+  const lines = [BEGIN, `# generated ${new Date().toISOString()} by ghprobe`];
+  for (const [domain, ip] of entries) {
+    lines.push(`${ip} ${domain}`);
+    for (const alt of extras.get(domain) || []) {
+      if (alt && alt !== ip) { lines.push(`${alt} ${domain}`); }
+    }
+  }
+  for (const [domain, ts] of absent) { lines.push(`# absent ${domain} ${ts}`); }
+  lines.push(END);
+  return lines.join("\n");
+}
+
+// 合法域名全集 = 主域名 + 兜底域名；缺失检测与 orphan 清理都以它为准
+export function targetDomains(cfg) {
+  const fb = Object.values(cfg.fallbacks || {}).flat();
+  return [...new Set([...(cfg.domains || []), ...fb])];
+}
+
+// 由一轮探测结果生成待写入的块。
+// 与 health 写出的块保持同构：没有活 IP 的目标域名记入 `# absent` 冷却注释，
+// 否则下次 health 会把这些域名当「缺失」而白跑一次全量。
+export function blockFromProbeResult(cfg, r) {
+  const maxPer = Math.max(1, cfg.hosts?.maxEntriesPerDomain ?? 2);
+  const entries = new Map();
+  const extras = new Map();
+  const put = (d, list) => {
+    if (!list || !list.length) { return; }
+    entries.set(d, list[0].ip);
+    const alt = list.slice(1, maxPer).map((x) => x.ip);
+    if (alt.length) { extras.set(d, alt); }
+  };
+  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 now = new Date().toISOString();
+  for (const d of targetDomains(cfg)) { if (!entries.has(d)) { absent.set(d, now); } }
+  return buildHealthBlock(entries, absent, extras);
+}
+
+// 全灭护栏（写入前判定）：新块一条有效 IP 都没有、而 hosts 里还有旧条目时，必须拒绝写入 ——
+// 否则会把原本可用的条目一起抹掉（`probe --apply` 此前缺这道护栏，只有 health 有）。
+export function shouldKeepOldBlock(oldContent, newBlock) {
+  return parseBlock(newBlock).entries.size === 0 && parseBlock(oldContent).entries.size > 0;
+}
+
+// 决策（纯函数）：输入已写入 IP 的探活结果 + 当前块状态，输出动作
+// 横向判据：严格多数条目同时失败视为网络故障（本轮不动，避开黑洞窗口）；
+// 单条目失败或缺失域名（非冷却）才触发全量重排
+export function decide(probeResults, current, cfg) {
+  const failed = new Set(probeResults.filter((r) => !r.ok).map((r) => r.domain));
+  const total = current.entries.size;
+
+  // 只有「已写入条目全部失败」才可能是网络级故障（黑洞窗口），此时本轮不动、避开窗口。
+  // 只要还有任意一条健康，就说明链路是通的，失败的那些是 IP 陈旧/真死，应当重排换 IP。
+  // 🔴 旧判据 `failed.size * 2 > total`（多数失败即放弃）已证实会误触发：分母只数已写入
+  //    条目、常低到 3~4，实测「3 条陈旧 + 1 条健康」被误判成断网 → 该修的时候不修。
+  if (total >= 2 && failed.size === total) {
+    return { action: "none", reason: "全部已写入 IP 同时失败，疑似网络故障" };
+  }
+
+  const cooldownMs = (cfg.schedule?.absentCooldownHours ?? 1) * 3600_000;
+  const now = Date.now();
+  const targets = targetDomains(cfg);
+  const missing = new Set();
+  for (const d of targets) {
+    if (current.entries.has(d)) { continue; }
+    const ts = current.absent.get(d);
+    if (ts && now - new Date(ts).getTime() < cooldownMs) { continue; }
+    missing.add(d);
+  }
+  // orphan：hosts 块里已不在配置（含兜底）中的域名，需清理
+  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(", ")}` };
+}
+
+// 部分更新（纯函数）：只改 diagnose 域名；全灭护栏保证不把好 IP 写成空
+// 返回的新 entries/absent 用于与当前对比，changed 记录真正换掉 IP 的域名
+// stuck：被诊断了、但本轮一个活 IP 都没找到、只能保留旧值的域名（黑洞窗口里必然出现，
+//        显式报出来，否则日志只写「无变化」会让人以为工具没干活）
+export function applyDelta(current, ranked, extra, diagnose, cfg) {
+  const entries = new Map(current.entries);
+  const extras = new Map(current.extras || []);
+  const absent = new Map(current.absent);
+  const changed = [];
+  const now = new Date().toISOString();
+  const allResult = new Map([...ranked, ...extra]);
+  const maxPer = Math.max(1, cfg.hosts?.maxEntriesPerDomain ?? 2);
+
+  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); }
+      absent.delete(d);
+    } else if (!entries.has(d)) {
+      absent.set(d, now);
+    }
+  }
+
+  // orphan 清理：hosts 块里已不在配置（含兜底）中的域名，无条件删除（主 IP 与备选一起删）
+  const allow = new Set(targetDomains(cfg));
+  for (const d of [...entries.keys()]) {
+    if (!allow.has(d)) { entries.delete(d); changed.push(d); }
+  }
+  for (const d of [...extras.keys()]) {
+    if (!allow.has(d) || !entries.has(d)) { extras.delete(d); }
+  }
+  // orphan 已在上一步删掉，这里只剩「配置内、诊断过、却没探到活 IP、于是保留旧值」的域名
+  const stuck = diagnose.filter((d) => allow.has(d) && entries.has(d) && !(allResult.get(d) || []).length);
+  return { entries, extras, absent, changed, stuck };
+}
+
+function sameMap(a, b) {
+  if (a.size !== b.size) { return false; }
+  for (const [k, v] of a) { if (b.get(k) !== v) { return false; } }
+  return true;
+}
+
+// 比较「域名 -> 备选 IP 数组」是否一致（值是有序数组，不能直接套 sameMap）
+function sameExtras(a, b) {
+  if (a.size !== b.size) { return false; }
+  for (const [k, v] of a) {
+    const w = b.get(k);
+    if (!w || w.length !== v.length) { return false; }
+    for (let i = 0; i < v.length; i++) { if (v[i] !== w[i]) { return false; } }
+  }
+  return true;
+}
+
+// 完整一轮健康检查：读 -> 测已写入 -> 决策 -> （异常时）全量探测 + 部分更新
+// write=true 时才真正 applyHosts（会弹 UAC），否则仅预览
+export async function runHealth(cfg, log, write = false, hostsPath = WIN_HOSTS) {
+  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);
+  }
+
+  const jobs = [...current.entries].map(([d, ip]) => () => probeIp(d, ip, cfg));
+  const probeResults = await pool(jobs, cfg.probe.concurrency);
+  for (const r of probeResults) {
+    say(`${r.ok ? "[OK ]" : "[FAIL]"} ${r.domain} @ ${r.ip} err=${r.err}`);
+  }
+
+  const decision = decide(probeResults, current, cfg);
+  if (decision.action === "none") {
+    say(`健康：${decision.reason}`);
+    return { action: "none", reason: decision.reason, block: null, stuck: [] };
+  }
+
+  say(`异常：${decision.reason}`);
+  return fullUpdate(cfg, log, content, current, decision.domains, write, hostsPath);
+}
+
+// 全量探测 + 部分更新 + 写回；护栏与粘性都在 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) {
+  const say = log || (() => {});
+  const r = await runProbe(cfg, log, diagnose);
+  const d = applyDelta(current, r.ranked, r.extra, diagnose, cfg);
+
+  const entriesChanged = !sameMap(d.entries, current.entries);
+  const absentChanged = !sameMap(d.absent, current.absent);
+  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 block = buildHealthBlock(d.entries, d.absent, d.extras);
+  const msg = d.changed.length ? `更新域名: ${d.changed.join(", ")}` : "更新缺失域名冷却记录";
+  if (write) {
+    const lock = acquireHostsLock();
+    if (!lock) {
+      say("另一进程正在写 hosts，本轮跳过（下轮健康检查会自动补写）");
+      return { action: "none", reason: "写锁冲突，本轮跳过", changed: d.changed, block, stuck: d.stuck };
+    }
+    try {
+      // 锁内重读最新 hosts：探测耗时期间他人可能已改过，避免覆盖别人刚写的新值
+      const latest = fs.readFileSync(hostsPath, "utf8");
+      await applyHosts(mergeHosts(latest, block));
+      say(`已写入 hosts：${msg}${stuckNote}`);
+    } finally { releaseHostsLock(lock); }
+  } else {
+    say(`预览块（加 --apply 才写入）:\n${block}`);
+  }
+  return { action: "full", reason: msg, changed: d.changed, block, stuck: d.stuck };
+}

package/src/hosts.js

@@ -0,0 +1,332 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// Copyright (C) 2026 zmw
+// hosts 片段生成 + 事务化提权写入 + 还原 + DNS 缓存刷新
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFile } from "node:child_process";
+
+export const WIN_HOSTS = "C:\\Windows\\System32\\drivers\\etc\\hosts";
+const BEGIN = "# === ghprobe begin ===";
+const END = "# === ghprobe end ===";
+
+// 用户级数据目录（日志、无窗口包装器）。放 %LOCALAPPDATA% 而不是包目录：
+// npm 全局安装时包目录在 node_modules 下，npm 升级/重装会整个换掉。
+export function userDataDir() {
+  const base = process.env.LOCALAPPDATA || path.join(os.homedir(), ".ghprobe");
+  return path.join(base, "ghprobe");
+}
+
+// 写 hosts 跨进程锁：probe --apply 与计划任务（health --apply）可能并发，避免读改写互踩
+export const HOSTS_LOCK = path.join(os.tmpdir(), "ghprobe-hosts.lock");
+const LOCK_STALE_MS = 60000;
+
+function sleepSync(ms) {
+  const sab = new SharedArrayBuffer(4);
+  Atomics.wait(new Int32Array(sab), 0, 0, ms);
+}
+
+// 抢写锁：wx 独占创建，冲突每 retryMs 重试，最多 timeoutMs；超时返回 null 表示本轮放弃。
+// 锁文件带随机 PID+时间戳；超出 LOCK_STALE_MS 视为持有进程崩溃残留，强清后重试。
+export function acquireHostsLock(timeoutMs = 5000, retryMs = 200) {
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    try {
+      const fd = fs.openSync(HOSTS_LOCK, "wx");
+      fs.writeSync(fd, `${process.pid} ${Date.now()}\n`);
+      return fd;
+    } catch (e) {
+      if (e.code !== "EEXIST") { throw e; }
+      try {
+        const st = fs.statSync(HOSTS_LOCK);
+        if (Date.now() - st.mtimeMs > LOCK_STALE_MS) { fs.unlinkSync(HOSTS_LOCK); continue; }
+      } catch { continue; } // 锁刚被持有者释放
+    }
+    if (Date.now() >= deadline) { return null; }
+    sleepSync(retryMs);
+  }
+}
+
+export function releaseHostsLock(fd) {
+  try { if (fd != null) { fs.closeSync(fd); } } catch { /* 忽略 */ }
+  try { fs.unlinkSync(HOSTS_LOCK); } catch { /* 忽略 */ }
+}
+
+// 从 ranked(域名->有序IP列表) 生成 hosts 块。
+// 🔴 每域名写 maxPer 条（默认 2）：**Windows 会把同名多条全部返回**（2026-10-11 实测，
+//    dns.lookup/all 与 curl 双证），且 curl / 浏览器会**逐个尝试** —— 黑洞 IP 排在前也能
+//    fallback 到后面的活 IP（实测 http=200 / 0.22s）。旧注释「只取第一条生效」是错的。
+//    所以多写 1 条备选 = 抖动时客户端自动兜底，不必干等下一轮健康检查（最长 1 分钟）。
+export function buildBlock(ranked, extraDomains, maxPer = 2) {
+  const lines = [BEGIN, `# generated ${new Date().toISOString()} by ghprobe`];
+  const put = (domain, rs) => {
+    for (const r of (rs || []).slice(0, Math.max(1, maxPer))) { lines.push(`${r.ip} ${domain}`); }
+  };
+  for (const [domain, rs] of ranked) {
+    if (rs.length) { put(domain, rs); }
+  }
+  for (const [domain, rs] of extraDomains || []) {
+    if (rs.length) { put(domain, rs); }
+  }
+  lines.push(END);
+  return lines.join("\n");
+}
+
+// 把新块合并进已有 hosts 内容：替换旧 ghprobe 块，其余行原样保留
+export function mergeHosts(current, block) {
+  const lines = String(current).split(/\r?\n/);
+  const out = [];
+  let inBlock = false;
+  for (const line of lines) {
+    if (line.startsWith(BEGIN)) { inBlock = true; continue; }
+    if (line.startsWith(END)) { inBlock = false; continue; }
+    if (!inBlock) { out.push(line); }
+  }
+  while (out.length && out[out.length - 1].trim() === "") { out.pop(); }
+  if (!block) { return out.join("\n") + (out.length ? "\n" : ""); }
+  const merged = [...out, "", block].join("\n");
+  return merged.endsWith("\n") ? merged : merged + "\n";
+}
+
+// 构造提权包装命令：Start-Process -Verb RunAs 拉起目标，并把被提升进程的退出码带回来。
+// 两个关键点（都踩过）：
+// ① 先把控制台输出编码设为 UTF-8 —— 否则 PowerShell 以 GBK 写 stderr，Node 按 UTF-8 解码会乱码，
+//    调用方 throw 出来的「提权写入失败: …」就变成一串问号。
+// ② 必须在 `exit $p.ExitCode` 之前判空：Start-Process 自身失败（典型是用户取消 UAC）时
+//    抛的是「非终止错误」，脚本会继续往下执行，$p 仍为 $null，而 `exit $null` 等价于
+//    退出码 0 —— 会把「提权失败」伪装成「成功」。-ErrorAction Stop 让它变成可捕获的终止错误。
+export function buildElevateCommand(file, args = []) {
+  const list = args.map((a) => `'${a}'`).join(",");
+  return `try { [Console]::OutputEncoding = [Text.Encoding]::UTF8 } catch {};`
+    + ` try { $p = Start-Process -FilePath '${file}' -Verb RunAs -Wait -PassThru -ArgumentList ${list} -ErrorAction Stop }`
+    + ` catch { [Console]::Error.WriteLine('提权失败: ' + $_.Exception.Message); exit 1 };`
+    + ` if ($null -eq $p) { exit 1 };`
+    + ` exit $p.ExitCode`;
+}
+
+// 构造「删除计划任务」的提权脚本。单独导出是为了可单测、可独立执行验证。
+// 两个关键点：
+// ① 任务不存在时直接 exit 0（幂等）—— uninstall 重复跑不应报错。
+// ② 删除动作必须 -ErrorAction Stop：否则「拒绝访问」这类错误是非终止的，脚本会继续走到
+//    末尾的 exit 0，把「删除失败」伪装成「成功」。
+export function buildUninstallTaskScript(taskName = "ghprobe") {
+  return `try { [Console]::OutputEncoding = [Text.Encoding]::UTF8 } catch {};`
+    + ` if (-not (Get-ScheduledTask -TaskName '${taskName}' -ErrorAction SilentlyContinue))`
+    + ` { [Console]::Error.WriteLine('计划任务 ${taskName} 不存在，跳过'); exit 0 };`
+    + ` try { Unregister-ScheduledTask -TaskName '${taskName}' -Confirm:$false -ErrorAction Stop }`
+    + ` catch { [Console]::Error.WriteLine('删除计划任务失败: ' + $_.Exception.Message); exit 1 };`
+    + ` exit 0`;
+}
+
+// 构造「写入 hosts + 注册计划任务」的提权脚本（install 用）：一次 UAC 完成两件事。
+// 与 buildApplyScript 的区别：中途不 exit，两件事都做完后再按综合结果返回退出码，
+// 这样 install 只需弹一次 UAC，且能拿到「两件事各自成功与否」的确定结果。
+export function buildInstallScript({ hostsPath, tmpPath, nodePath, binPath, cfgArg = "", minutes = 1, writeHosts = true, vbsPath = "" }) {
+  const bak = `${hostsPath}.ghprobe-bak`;
+  const hostsPart = writeHosts ? `
+try {
+  Copy-Item -Force $src $bak
+  Copy-Item -Force $tmp $src
+  $now = [IO.File]::ReadAllText($src, $enc)
+  if ($now -match [regex]::Escape($marker)) { $hostsOk = $true }
+  else { Copy-Item -Force $bak $src; [Console]::Error.WriteLine('hosts 校验失败：未找到 ghprobe 标记，已回滚') }
+} catch {
+  if (Test-Path $bak) { Copy-Item -Force $bak $src }
+  [Console]::Error.WriteLine('hosts 写入失败: ' + $_.Exception.Message)
+}
+if ($hostsOk) { ipconfig /flushdns | Out-Null }` : "";
+  // 任务动作二选一：
+  // ① 有 VBS 包装器（默认）→ 用 wscript.exe 跑它，VBS 内以 SW_HIDE 启动 node —— 全程无窗口；
+  // ② 没有（老调用方 / 包装器写失败）→ 直接跑 node，功能不受影响，但会闪一个控制台窗口。
+  const actionLine = vbsPath
+    ? `$a = New-ScheduledTaskAction -Execute "$env:SystemRoot\\System32\\wscript.exe" -Argument ('"' + '${vbsPath}' + '"')`
+    : `$a = New-ScheduledTaskAction -Execute '${nodePath}' -Argument '"${binPath}" health --apply${cfgArg}'`;
+  return `
+try { [Console]::OutputEncoding = [Text.Encoding]::UTF8 } catch {}
+$src = '${hostsPath}'
+$tmp = '${tmpPath}'
+$bak = '${bak}'
+$marker = '${BEGIN}'
+$enc = [Text.Encoding]::Default
+$hostsOk = $${writeHosts ? "false" : "true"}
+${hostsPart}
+$taskOk = $false
+try {
+  ${actionLine}
+  $t = New-ScheduledTaskTrigger -Once -At (Get-Date) -RepetitionInterval (New-TimeSpan -Minutes ${minutes})
+  $p = New-ScheduledTaskPrincipal -UserId "$env:COMPUTERNAME\\$env:USERNAME" -LogonType Interactive -RunLevel Highest
+  Register-ScheduledTask -TaskName ghprobe -Action $a -Trigger $t -Principal $p -Force | Out-Null
+  $taskOk = $true
+} catch {
+  [Console]::Error.WriteLine('注册计划任务失败: ' + $_.Exception.Message)
+}
+if ($hostsOk -and $taskOk) { exit 0 }
+exit 1
+`;
+}
+
+// 构造「无窗口运行」包装器（VBScript）。
+// 为什么需要它：Task Scheduler 在交互会话里启动控制台程序（node.exe）会**必然**新建一个
+// 控制台窗口，而 node.exe 没有任何「隐藏窗口」开关（不像 powershell 有 -WindowStyle Hidden）。
+// 唯一可靠的做法是让 wscript.exe 起一层：WScript.Shell.Run 的第二个参数是 ShowWindow 风格，
+// 传 0 = SW_HIDE，且该方式自 Win7 起一直有效。第三个参数 True = 等子进程结束再退出。
+// 🔴 注释必须**纯 ASCII**：这个文件以 "ascii" 编码落盘（wscript 对无 BOM 的 .vbs 按 ANSI 解析，
+//    写 UTF-8 中文会变乱码），中文字符会被掩掉高位变成一堆问号/方块。
+// VBS 字符串里 `"` 要写成 `""`（成对双写），所以路径里的引号要整体转义一遍。
+export function buildHiddenRunnerVbs(nodePath, binPath, args = "") {
+  const cmd = `"${nodePath}" "${binPath}"${args ? " " + args : ""}`;
+  return [
+    "' ghprobe hidden-runner wrapper - generated by \"ghprobe install\", removed by \"ghprobe uninstall\".",
+    "' Do not edit. ASCII-only on purpose (wscript reads BOM-less .vbs as ANSI).",
+    'Set sh = CreateObject("WScript.Shell")',
+    `sh.Run "${cmd.replace(/"/g, '""')}", 0, True`,
+    "",
+  ].join("\r\n");
+}
+
+// 判断当前进程是否已经有管理员权限：hosts 是只有管理员能写的系统文件，
+// 用「以读写方式打开」做探测，成功即已提权。比 spawn 一个 PowerShell 去查 token 便宜得多，
+// 而且不产生任何窗口。已提权时 applyHosts 直接跑脚本，不再走 Start-Process -Verb RunAs
+// （那条路会再拉一个新控制台窗口，无窗口运行就破了）。
+export function isElevated(hostsPath = WIN_HOSTS) {
+  try { fs.closeSync(fs.openSync(hostsPath, "r+")); return true; } catch { return false; }
+}
+
+// 跑一段 PowerShell 命令，回传 { code, out, err }
+function runPowerShellCommand(cmd) {
+  return new Promise((resolve, reject) => {
+    const child = execFile("powershell", ["-NoProfile", "-Command", cmd], { windowsVerbatimArguments: true, windowsHide: true });
+    let out = "";
+    let err = "";
+    child.stdout?.on("data", (d) => { out += d; });
+    child.stderr?.on("data", (d) => { err += d; });
+    child.on("close", (code) => resolve({ code, out, err }));
+    child.on("error", reject);
+  });
+}
+
+// 直接执行一个 .ps1（调用方保证已经提权）。windowsHide 让 powershell 以 CREATE_NO_WINDOW
+// 启动，不闪窗；被提升的父进程若本身就在隐藏控制台里，子进程也是继承而非新建。
+function runPowerShellFile(file) {
+  return new Promise((resolve, reject) => {
+    const child = execFile("powershell", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", file], { windowsHide: true });
+    let out = "";
+    let err = "";
+    child.stdout?.on("data", (d) => { out += d; });
+    child.stderr?.on("data", (d) => { err += d; });
+    child.on("close", (code) => resolve({ code, out, err }));
+    child.on("error", reject);
+  });
+}
+
+// 跑一次提权包装。单独导出是为了让回归测试能注入一个必然失败的 Start-Process 目标，
+// 从而验证「提权失败不会退化成退出码 0」。
+export function runElevationWrapper(file, args = []) {
+  return runPowerShellCommand(buildElevateCommand(file, args));
+}
+
+// 写提权脚本文件。🔴 必须带 UTF-8 BOM：PowerShell 5.1 对「无 BOM 的 .ps1」按系统 ANSI
+// 代码页（中文系统 = GBK）解析，脚本里的中文字面量（错误提示）会整段变乱码。
+// 加 BOM 后 PS 才按 UTF-8 解析。注意这条路径与 buildElevateCommand 不同 ——
+// 那条走 `-Command`，参数由 CreateProcessW 以 UTF-16 传递，本来就不受文件编码影响。
+export function writePs1WithBom(file, content) {
+  fs.writeFileSync(file, "\ufeff" + content, "utf8");
+}
+
+// 写临时 ps1 -> 提权执行 -> 取回退出码 -> 清理 ps1（apply/restore/install 复用）。
+// 已经提权时（计划任务 runlevel=highest）直接执行脚本，不走 Start-Process -Verb RunAs ——
+// 后者会再拉一个独立控制台窗口，是「无窗口运行」的第二个破口。
+export async function runElevated(content) {
+  const tmp = path.join(os.tmpdir(), `ghprobe-${Date.now()}.ps1`);
+  writePs1WithBom(tmp, content);
+  try {
+    if (isElevated()) { return await runPowerShellFile(tmp); }
+    return await runElevationWrapper("powershell", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", tmp]);
+  } finally {
+    try { fs.unlinkSync(tmp); } catch { /* 清理失败不管 */ }
+  }
+}
+
+// 构造 hosts 写入脚本（由 runElevated 提权执行）。两个要点：
+// ① 备份**每次刷新**（不是「只建一次」）—— 只建一次时，若 hosts 在安装后被第三方追加了
+//    条目，那份陈旧备份里没有它们，卸载/回滚时会把它们一起抹掉。
+// ② 读写统一用 [Text.Encoding]::Default（系统 ANSI 代码页），保证 hosts 里的非 ASCII
+//    注释（不少工具会写中文标记）编码不变。
+export function buildApplyScript(hostsPath, tmpPath) {
+  const bak = `${hostsPath}.ghprobe-bak`;
+  return `
+try { [Console]::OutputEncoding = [Text.Encoding]::UTF8 } catch {}
+$src = '${hostsPath}'
+$tmp = '${tmpPath}'
+$bak = '${bak}'
+$marker = '${BEGIN}'
+$enc = [Text.Encoding]::Default
+try {
+  Copy-Item -Force $src $bak
+  Copy-Item -Force $tmp $src
+  $now = [IO.File]::ReadAllText($src, $enc)
+  if ($now -notmatch [regex]::Escape($marker)) {
+    Copy-Item -Force $bak $src
+    [Console]::Error.WriteLine('hosts 校验失败：未找到 ghprobe 标记，已回滚')
+    exit 1
+  }
+  ipconfig /flushdns | Out-Null
+  exit 0
+} catch {
+  if (Test-Path $bak) { Copy-Item -Force $bak $src }
+  [Console]::Error.WriteLine('hosts 写入失败: ' + $_.Exception.Message)
+  exit 1
+}
+`;
+}
+
+// 构造 hosts 还原脚本（由 runElevated 提权执行）：剥掉整个 ghprobe 块后写回。
+// 刻意**不**用 *.ghprobe-bak 直接覆盖 —— 备份是「写入前」的快照，可能含旧块，也可能
+// 早于第三方后来追加的条目。直接剥块才能保证「只移除 ghprobe 自己的行」。
+// 🔴 必须用状态机跳过 begin..end 之间的**所有行**：早期写法是 `Where-Object { $_ -notmatch
+//    '^# === ghprobe (begin|end) ===' }`，它只删标记行、把块内 IP 条目全留下 ——
+//    以前靠备份分支兜着没暴露，去掉备份分支后就会留下一堆孤儿条目。
+export function buildRestoreScript(hostsPath) {
+  return `
+try { [Console]::OutputEncoding = [Text.Encoding]::UTF8 } catch {}
+$src = '${hostsPath}'
+$enc = [Text.Encoding]::Default
+try {
+  $current = [IO.File]::ReadAllText($src, $enc)
+  $keep = @()
+  $skip = $false
+  foreach ($line in ($current -split '\\r?\\n')) {
+    if ($line -match '^# === ghprobe begin ===') { $skip = $true; continue }
+    if ($line -match '^# === ghprobe end ===') { $skip = $false; continue }
+    if (-not $skip) { $keep += $line }
+  }
+  $clean = ($keep -join [Environment]::NewLine).TrimEnd() + [Environment]::NewLine
+  [IO.File]::WriteAllText($src, $clean, $enc)
+  ipconfig /flushdns | Out-Null
+  exit 0
+} catch {
+  [Console]::Error.WriteLine('hosts 还原失败: ' + $_.Exception.Message)
+  exit 1
+}
+`;
+}
+
+// 事务化提权写入：刷新备份 -> 覆盖 -> 校验含 BEGIN -> 失败回滚 -> 刷 DNS 缓存
+export async function applyHosts(merged, hostsPath = WIN_HOSTS) {
+  const tmp = path.join(os.tmpdir(), `ghprobe-hosts-${Date.now()}.tmp`);
+  fs.writeFileSync(tmp, merged, "utf8");
+  try {
+    const r = await runElevated(buildApplyScript(hostsPath, tmp));
+    if (r.code !== 0) { throw new Error(`提权写入失败: ${r.err || r.out}`); }
+    return { ok: true, backup: `${hostsPath}.ghprobe-bak` };
+  } finally {
+    try { fs.unlinkSync(tmp); } catch { /* 清理失败不管 */ }
+  }
+}
+
+// 还原 hosts：剥掉 ghprobe 块后写回；最后刷 DNS 缓存
+export async function restoreHosts(hostsPath = WIN_HOSTS) {
+  const r = await runElevated(buildRestoreScript(hostsPath));
+  if (r.code !== 0) { throw new Error(`还原 hosts 失败: ${r.err || r.out}`); }
+  return { ok: true };
+}