cfpilot-scanner 0.2.0 → 0.3.0

package/README.md

@@ -32,6 +32,38 @@ npx -y cfpilot-scanner scan --host cfpilot.example.com --token <令牌>
 npx -y cfpilot-scanner scan --host cfpilot.example.com --no-callback --top 20
 ```
 
+## 运行前必须关闭代理工具
+
+> ⚠️ 这是最容易踩的坑，也是「结果看起来正常但导入客户端全是 -1」的头号原因。
+
+本工具测的是**本机直连某个 IP 的真实质量**。
+只要本机有代理工具在接管流量，测出来的就是**到代理的延迟**，而不是到目标 IP 的延迟：
+
+- Clash / Mihomo（含 TUN 模式、系统代理）
+- v2rayN / v2rayNG
+- sing-box / Nekoray
+- Surge / Quantumult
+
+**症状**：扫描不报错、结果看起来正常，但所有候选 IP 成绩趋于一致
+（常常集中在一个小网段），导入客户端后大量 `-1` —— 因为从未真正直连验证过。
+
+工具会在扫描前自动检测，发现异常会打印提醒：
+
+```
+⚠️  检测到可能干扰优选的因素：
+   本机有代理程序在监听：
+     Clash Verge → 127.0.0.1:7897
+    → 关闭这些代理程序，或在其中把本程序加入直连/绕过名单
+   DNS 把 your-domain.com 解析到 198.18.0.82（198.18/15 保留段），TUN / fake-ip 正在生效
+    → 关闭代理工具的 TUN 模式与 fake-ip DNS
+```
+
+检测到问题**不会阻断扫描**（有些人确实需要走代理，比如域名在本地被污染），
+但结果的可信度由你自己判断。
+
+如果必须开着代理，请把它加入直连/绕过名单，
+并确保**待测的 Cloudflare IP 段**走直连而不是代理节点。
+
 ## 对接任意 VLESS-WS 项目（CFNext / cfnew / BPB / edgetunnel）
 
 不依赖 CFPilot 自己的探针端点，只要知道你项目的 **WebSocket 路径**即可：
@@ -42,11 +74,58 @@ npx -y cfpilot-scanner scan --host your-domain.com --path /<uuid> --no-callback
 
 # 常见约定：/vless
 npx -y cfpilot-scanner scan --host your-domain.com --path /vless --no-callback
+
+# 有些项目把 WebSocket 放在根路径，那就填 /
+npx -y cfpilot-scanner scan --host your-domain.com --path / --no-callback
 ```
 
+**路径必须与目标项目实际的 WebSocket 路径完全一致**，填错一个 IP 都选不出来。
+不知道就分别试 `/` 和 `/vless`，能出结果的那个就是对的。
+
 - 阶段二会对 `<path>` 发起真实的 **TLS + WebSocket 101** 握手，只有 101 才算可用
-- 如果目标没有测速端点，会自动跳过测速、只按延迟排序（不会再干等 12 秒）
-- 想测速可加 `--probe-path <路径>` 与 `--no-speed` 控制行为
+- **测速支持任意项目**，不需要对方提供任何端点（见下节）
+- 想控制行为可用 `--speed-mode`、`--speed-url`、`--no-speed`
+
+## 测速：两种方式，只对已校验的 IP 生效
+
+**关键前提**：测速**只作用于已通过 101 校验的 IP**。这一点很重要 ——
+同类工具常见的失败模式是「只测带宽、不校验能不能服务你的域名」，
+结果选出的 IP 速度很快，导入客户端却全是 `-1`。
+
+| 方式 | 什么时候用 | 要求 | 忠实度 |
+|------|-----------|------|--------|
+| `probe` | 目标有 CFPilot 探针端点（如 `/__edge_probe`） | 目标须提供该端点 | 高（走代理真实路径） |
+| `url` | 其它任何项目 | 无 | 中（测「候选 IP 到 Cloudflare 边缘」的带宽） |
+
+默认 `--speed-mode auto`：自动探测目标有没有探针端点，有就走 `probe`，没有就切 `url`。
+**因此对接第三方项目时速度不再永远是 0。**
+
+```bash
+# 强制用公开测速地址（任何项目都能测出速度）
+npx -y cfpilot-scanner scan --host your-domain.com --path /vless \
+  --speed-mode url --no-callback
+
+# 换成自己的测速地址（需返回大文件）
+npx -y cfpilot-scanner scan --host your-domain.com --path /vless \
+  --speed-url "cdn.example.com/big.bin" --no-callback
+```
+
+### 测速精度的几个设计点
+
+1. **取滑动窗口峰值，而不是总平均**
+   TCP 慢启动会让开头 1~2 秒的速率远低于链路实际能力。
+   实测同一 IP：峰值 `51.7 MB/s`、总平均仅 `16.4 MB/s` —— 用平均会严重低估。
+   因此默认丢弃前 1 秒的样本，再取窗口速率的最大值。
+
+2. **默认 3 条并发连接**（`--speed-conns`）
+   单条 TCP 连接受拥塞窗口与 BDP 限制，高延迟线路上往往填不满实际带宽。
+
+3. **测速地址可用性预检**
+   测速地址本身可能在本网络下不可用。启动时并行探测候选地址，
+   自动选用可用的那个，避免把「地址不可用」误判成「所有 IP 速度都是 0」。
+
+4. **默认 6 秒测量时长**（`--speed-duration`）
+   太短会被慢启动拉低，太长浪费时间。
 
 ## 输出：直接可复制的列表
 

package/dist/cli.js

@@ -1,4 +1,10 @@
 #!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/cli.ts
 import { readFileSync } from "node:fs";
@@ -212,25 +218,56 @@ function expandCidrs(cidrs, options = {}) {
   const random = makeRandom(options.seed ?? 24301);
   const parsed = cidrs.map(parseCidr).filter((c) => c !== null);
   if (parsed.length === 0) return [];
-  const totalSize = parsed.reduce((sum, c) => sum + c.size, 0n);
-  const out = [];
-  for (const cidr of parsed) {
-    if (sample <= 0 || cidr.size <= 2000n) {
+  if (sample <= 0) {
+    const all = [];
+    for (const cidr of parsed) {
       for (let i = 0n; i < cidr.size; i++) {
         const value = cidr.base + i;
-        out.push(cidr.family === 4 ? bigIntToIpv4(value) : bigIntToIpv6(value));
+        all.push(cidr.family === 4 ? bigIntToIpv4(value) : bigIntToIpv6(value));
       }
-      continue;
     }
-    const ratio = Number(totalSize === 0n ? 1n : cidr.size * BigInt(sample) / totalSize);
-    const count = Math.max(64, Math.min(2e4, ratio));
-    const step = Number(cidr.size / BigInt(count));
-    const offset = Math.floor(random() * step);
-    for (let i = 0; i < count; i++) {
-      const offsetValue = BigInt(offset + Math.floor(i * step));
-      if (offsetValue >= cidr.size) break;
-      const value = cidr.base + offsetValue;
-      out.push(cidr.family === 4 ? bigIntToIpv4(value) : bigIntToIpv6(value));
+    return all;
+  }
+  const minPerCidr = sample <= 1e3 ? 1 : 64;
+  const out = [];
+  for (const family of [4, 6]) {
+    const group = parsed.filter((c) => c.family === family);
+    if (group.length === 0) continue;
+    const familyTotal = group.reduce((sum, c) => sum + c.size, 0n);
+    if (familyTotal === 0n) continue;
+    const hasOtherFamily = parsed.some((c) => c.family !== family);
+    const familyBudget = Math.max(1, Math.round(hasOtherFamily ? sample / 2 : sample));
+    const plans = group.map((cidr) => {
+      const ratio = Number(cidr.size * BigInt(familyBudget) / familyTotal);
+      const wanted = Math.max(minPerCidr, Math.min(2e4, ratio));
+      return { cidr, count: Math.min(Number(cidr.size), wanted) };
+    });
+    let familySum = plans.reduce((sum, p) => sum + p.count, 0);
+    while (familySum > familyBudget) {
+      let target = null;
+      for (const plan of plans) {
+        if (plan.count > 1 && (!target || plan.count > target.count)) target = plan;
+      }
+      if (!target) break;
+      target.count -= 1;
+      familySum -= 1;
+    }
+    for (const { cidr, count } of plans) {
+      if (count >= Number(cidr.size)) {
+        for (let i = 0n; i < cidr.size; i++) {
+          const value = cidr.base + i;
+          out.push(family === 4 ? bigIntToIpv4(value) : bigIntToIpv6(value));
+        }
+        continue;
+      }
+      const step = Math.floor(Number(cidr.size) / count);
+      const offset = Math.floor(random() * step);
+      for (let i = 0; i < count; i++) {
+        const offsetValue = BigInt(offset + Math.floor(i * step));
+        if (offsetValue >= cidr.size) break;
+        const value = cidr.base + offsetValue;
+        out.push(family === 4 ? bigIntToIpv4(value) : bigIntToIpv6(value));
+      }
     }
   }
   return out;
@@ -326,11 +363,239 @@ function normalizeCandidateList(input) {
   return out;
 }
 
-// src/scan.ts
+// src/net-env.ts
 import * as net from "node:net";
+import { execFile } from "node:child_process";
+var PROXY_PORTS = [
+  { port: 7890, name: "Clash / Mihomo\uFF08HTTP\uFF09" },
+  { port: 7891, name: "Clash / Mihomo\uFF08SOCKS\uFF09" },
+  { port: 7897, name: "Clash Verge" },
+  { port: 1080, name: "\u901A\u7528 SOCKS" },
+  { port: 10808, name: "v2rayN\uFF08SOCKS\uFF09" },
+  { port: 10809, name: "v2rayN\uFF08HTTP\uFF09" },
+  { port: 2080, name: "Nekoray / sing-box" },
+  { port: 2081, name: "Nekoray / sing-box" },
+  { port: 8889, name: "Surge" },
+  { port: 6152, name: "Surge\uFF08HTTP\uFF09" }
+];
+function isPortListening(port, timeoutMs = 400) {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    let settled = false;
+    const done = (open) => {
+      if (settled) return;
+      settled = true;
+      try {
+        socket.destroy();
+      } catch {
+      }
+      resolve(open);
+    };
+    socket.setTimeout(timeoutMs, () => done(false));
+    socket.once("connect", () => done(true));
+    socket.once("error", () => done(false));
+    try {
+      socket.connect(port, "127.0.0.1");
+    } catch {
+      done(false);
+    }
+  });
+}
+async function readSystemProxy() {
+  if (process.platform !== "win32") return "";
+  const query = (key) => new Promise((resolve) => {
+    execFile(
+      "reg",
+      ["query", "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings", "/v", key],
+      { timeout: 3e3, windowsHide: true },
+      (err, stdout) => resolve(err ? "" : String(stdout))
+    );
+  });
+  try {
+    const enabled = await query("ProxyEnable");
+    if (!/ProxyEnable\s+REG_DWORD\s+0x1/i.test(enabled)) return "";
+    const server = await query("ProxyServer");
+    const m = /ProxyServer\s+REG_SZ\s+(\S+)/i.exec(server);
+    return m ? m[1] : "(\u5DF2\u542F\u7528\uFF0C\u4F46\u672A\u8BFB\u5230\u5730\u5740)";
+  } catch {
+    return "";
+  }
+}
+function isFakeIp(ip) {
+  const parts = ip.split(".").map(Number);
+  const [a, b] = parts;
+  return a === 198 && (b === 18 || b === 19);
+}
+async function detectProxyInterference(host) {
+  const findings = [];
+  const listening = [];
+  await Promise.all(
+    PROXY_PORTS.map(async ({ port, name }) => {
+      if (await isPortListening(port)) listening.push(`${name} \u2192 127.0.0.1:${port}`);
+    })
+  );
+  if (listening.length > 0) {
+    findings.push({
+      message: "\u672C\u673A\u6709\u4EE3\u7406\u7A0B\u5E8F\u5728\u76D1\u542C\uFF1A\n     " + listening.join("\n     "),
+      advice: "\u5173\u95ED\u8FD9\u4E9B\u4EE3\u7406\u7A0B\u5E8F\uFF0C\u6216\u5728\u5176\u4E2D\u628A\u672C\u7A0B\u5E8F\u52A0\u5165\u76F4\u8FDE/\u7ED5\u8FC7\u540D\u5355"
+    });
+  }
+  const sysProxy = await readSystemProxy();
+  if (sysProxy) {
+    findings.push({
+      message: `\u7CFB\u7EDF\u4EE3\u7406\u5DF2\u542F\u7528\uFF1A${sysProxy}`,
+      advice: "\u5728\u300C\u8BBE\u7F6E \u2192 \u7F51\u7EDC\u548C Internet \u2192 \u4EE3\u7406\u300D\u4E2D\u5173\u95ED\u7CFB\u7EDF\u4EE3\u7406"
+    });
+  }
+  const probeHost = host?.trim() || "www.cloudflare.com";
+  try {
+    const { resolve4 } = await import("node:dns/promises");
+    const ips = await resolve4(probeHost).catch(() => []);
+    const fake = ips.find((ip) => isFakeIp(ip));
+    if (fake) {
+      findings.push({
+        message: `DNS \u628A ${probeHost} \u89E3\u6790\u5230 ${fake}\uFF08198.18/15 \u4FDD\u7559\u6BB5\uFF09\uFF0CTUN / fake-ip \u6B63\u5728\u751F\u6548`,
+        advice: "\u5173\u95ED\u4EE3\u7406\u5DE5\u5177\u7684 TUN \u6A21\u5F0F\u4E0E fake-ip DNS"
+      });
+    }
+  } catch {
+  }
+  return { clean: findings.length === 0, findings };
+}
+function isMsysPollutedPath(value) {
+  const looksWindows = /^[A-Za-z]:[\\/]/.test(value) || value.includes("\\");
+  const hasMsysHint = /node_modules|bash-win32|@dsh-ops|msys/i.test(value);
+  return looksWindows || hasMsysHint;
+}
 
-// src/true-probe.ts
+// src/speed-url.ts
 import * as tls from "node:tls";
+var SPEED_URL_PRESETS = [
+  { url: "speed.cloudflare.com/__down?bytes=104857600", label: "Cloudflare \u5B98\u65B9" },
+  { url: "cf.090227.xyz/__down?bytes=104857600", label: "CM \u63D0\u4F9B" }
+];
+var DEFAULT_SPEED_URL = SPEED_URL_PRESETS[0].url;
+function parseSpeedUrl(raw, fallbackScheme = "https") {
+  const value = (raw ?? "").trim();
+  if (!value) throw new Error("\u6D4B\u901F\u5730\u5740\u4E3A\u7A7A");
+  const schemeMatch = /^([a-z][a-z0-9+.-]*):\/\//i.exec(value);
+  if (schemeMatch) {
+    const scheme2 = schemeMatch[1].toLowerCase();
+    if (scheme2 !== "http" && scheme2 !== "https") {
+      throw new Error(`\u4E0D\u652F\u6301\u7684\u6D4B\u901F\u5730\u5740\u534F\u8BAE\uFF1A${scheme2}\uFF08\u53EA\u652F\u6301 http / https\uFF09`);
+    }
+  }
+  let normalized = value;
+  if (normalized.startsWith("//")) {
+    normalized = `${fallbackScheme}:${normalized}`;
+  } else if (!/^https?:\/\//i.test(normalized)) {
+    normalized = `${fallbackScheme}://${normalized}`;
+  }
+  let parsed;
+  try {
+    parsed = new URL(normalized);
+  } catch {
+    throw new Error(`\u6D4B\u901F\u5730\u5740\u65E0\u6CD5\u89E3\u6790\uFF1A${value}`);
+  }
+  const scheme = parsed.protocol.replace(":", "").toLowerCase();
+  if (scheme !== "http" && scheme !== "https") {
+    throw new Error(`\u4E0D\u652F\u6301\u7684\u6D4B\u901F\u5730\u5740\u534F\u8BAE\uFF1A${scheme}`);
+  }
+  if (!parsed.hostname) throw new Error(`\u6D4B\u901F\u5730\u5740\u7F3A\u5C11\u57DF\u540D\uFF1A${value}`);
+  return {
+    raw: value,
+    scheme,
+    host: parsed.hostname,
+    path: `${parsed.pathname}${parsed.search}` || "/"
+  };
+}
+function schemeForPort(port) {
+  return port === 443 || port === 2053 || port === 2083 || port === 2087 || port === 2096 || port === 8443 ? "https" : "http";
+}
+function checkSpeedUrlAvailable(parsed, timeoutMs = 6e3) {
+  return new Promise((resolve) => {
+    let settled = false;
+    let received = "";
+    const finish = (available, status, error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        socket.destroy();
+      } catch {
+      }
+      resolve({ available, status, error });
+    };
+    const path = parsed.path.includes("bytes=") ? parsed.path.replace(/bytes=\d+/, "bytes=1024") : parsed.path;
+    const request = [
+      `GET ${path} HTTP/1.1`,
+      `Host: ${parsed.host}`,
+      `User-Agent: ${USER_AGENT_FOR_CHECK}`,
+      "Accept: */*",
+      "Connection: close",
+      "",
+      ""
+    ].join("\r\n");
+    const connectOptions = {
+      host: parsed.host,
+      port: parsed.scheme === "https" ? 443 : 80,
+      servername: parsed.host,
+      rejectUnauthorized: false
+    };
+    const socket = parsed.scheme === "https" ? tls.connect(connectOptions, () => socket.write(request)) : (
+      // http 明文：用 net 连接
+      (() => {
+        const net3 = __require("node:net");
+        const s = net3.connect({ host: parsed.host, port: 80 }, () => s.write(request));
+        return s;
+      })()
+    );
+    const timer = setTimeout(() => finish(false, 0, "\u9884\u68C0\u8D85\u65F6"), timeoutMs);
+    socket.setTimeout(timeoutMs, () => finish(false, 0, "\u9884\u68C0\u8D85\u65F6"));
+    socket.on("error", (err) => finish(false, 0, err.message));
+    socket.on("data", (chunk) => {
+      received += chunk.toString("utf8");
+      const m = /^HTTP\/1\.[01]\s+(\d{3})/.exec(received);
+      if (m) {
+        const status = Number(m[1]);
+        finish(status === 200 || status === 206, status);
+      }
+    });
+  });
+}
+var USER_AGENT_FOR_CHECK = "CFPilot-Scanner/1.0 (+https://github.com/xmwengxing/CFPilot)";
+async function pickAvailableSpeedUrl(candidates, log) {
+  const list = candidates.length > 0 ? candidates : [DEFAULT_SPEED_URL];
+  for (const candidate of list) {
+    let parsed;
+    try {
+      parsed = parseSpeedUrl(candidate, "https");
+    } catch {
+      continue;
+    }
+    const result = await checkSpeedUrlAvailable(parsed);
+    if (result.available) {
+      log?.(`\u6D4B\u901F\u5730\u5740\u53EF\u7528\uFF1A${candidate}`);
+      return candidate;
+    }
+    log?.(`\u6D4B\u901F\u5730\u5740\u4E0D\u53EF\u7528\uFF08${result.error ?? "HTTP " + result.status}\uFF09\uFF1A${candidate}`);
+  }
+  log?.(`\u6240\u6709\u6D4B\u901F\u5730\u5740\u90FD\u4E0D\u53EF\u7528\uFF0C\u56DE\u9000\u5230\u9ED8\u8BA4\uFF1A${DEFAULT_SPEED_URL}`);
+  return DEFAULT_SPEED_URL;
+}
+function withBytes(parsed, bytes) {
+  if (/bytes=\d+/.test(parsed.path)) {
+    return parsed.path.replace(/bytes=\d+/, `bytes=${bytes}`);
+  }
+  const sep = parsed.path.includes("?") ? "&" : "?";
+  return `${parsed.path}${sep}bytes=${bytes}`;
+}
+
+// src/scan.ts
+import * as net2 from "node:net";
+
+// src/true-probe.ts
+import * as tls2 from "node:tls";
 import * as crypto from "node:crypto";
 var USER_AGENT = "CFPilot-Scanner/1.0 (+https://github.com/xmwengxing/CFPilot)";
 function extractColo(text) {
@@ -364,7 +629,7 @@ function probeWs101(ip, port, host, timeoutMs = 3e3, path = "/__edge_probe") {
       "",
       ""
     ].join("\r\n");
-    const socket = tls.connect(
+    const socket = tls2.connect(
       {
         host: ip,
         port,
@@ -430,7 +695,7 @@ function measureDownload(ip, port, host, bytes, timeoutMs = 12e3, path = "/__edg
       "",
       ""
     ].join("\r\n");
-    const socket = tls.connect(
+    const socket = tls2.connect(
       {
         host: ip,
         port,
@@ -489,13 +754,215 @@ function measureDownload(ip, port, host, bytes, timeoutMs = 12e3, path = "/__edg
     socket.on("close", settle);
   });
 }
+function measureThroughput(options) {
+  const {
+    ip,
+    port,
+    sniHost,
+    path,
+    requestHost = sniHost,
+    durationMs = 6e3,
+    warmupMs = 1e3,
+    windowMs = 400,
+    connections = 3,
+    timeoutMs = 2e4
+  } = options;
+  const connCount = Math.max(1, Math.min(8, connections));
+  return new Promise((resolve) => {
+    const started = Date.now();
+    let settled = false;
+    let totalBytes = 0;
+    let windowBytes = 0;
+    let windowStart = started;
+    let peak = 0;
+    let openedCount = 0;
+    let lastError = "";
+    const sockets = [];
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      clearInterval(ticker);
+      clearTimeout(timer);
+      for (const s of sockets) {
+        try {
+          s.destroy();
+        } catch {
+        }
+      }
+      const elapsedNow = Date.now() - started;
+      if (elapsedNow >= warmupMs) {
+        const dt = (Date.now() - windowStart) / 1e3;
+        if (dt > 0) {
+          const speed = windowBytes / dt / 1024 / 1024;
+          if (speed > peak) peak = speed;
+        }
+      }
+      const elapsed = Math.max(1e-3, (Date.now() - started) / 1e3);
+      resolve({
+        ok: totalBytes > 0,
+        bytes: totalBytes,
+        ms: Date.now() - started,
+        peakMBps: Number(peak.toFixed(2)),
+        avgMBps: Number((totalBytes / 1024 / 1024 / elapsed).toFixed(2)),
+        connections: openedCount,
+        error: totalBytes > 0 ? void 0 : lastError || "\u672A\u6536\u5230\u6570\u636E"
+      });
+    };
+    const request = [
+      `GET ${path} HTTP/1.1`,
+      `Host: ${requestHost}`,
+      `User-Agent: ${USER_AGENT}`,
+      "Accept: */*",
+      "Accept-Encoding: identity",
+      "Connection: close",
+      "",
+      ""
+    ].join("\r\n");
+    const openOne = () => {
+      let headerDone = false;
+      let headerBuffer = "";
+      const socket = tls2.connect(
+        {
+          host: ip,
+          port,
+          servername: sniHost,
+          rejectUnauthorized: false,
+          ALPNProtocols: ["http/1.1"]
+        },
+        () => {
+          openedCount++;
+          socket.write(request);
+        }
+      );
+      sockets.push(socket);
+      socket.setTimeout(timeoutMs, () => {
+        try {
+          socket.destroy();
+        } catch {
+        }
+      });
+      socket.on("error", (err) => {
+        lastError = err.message;
+      });
+      socket.on("data", (chunk) => {
+        if (!headerDone) {
+          headerBuffer += chunk.toString("latin1");
+          const idx = headerBuffer.indexOf("\r\n\r\n");
+          if (idx < 0) {
+            if (headerBuffer.length > 8192) {
+              lastError = "\u54CD\u5E94\u5934\u5F02\u5E38";
+              socket.destroy();
+            }
+            return;
+          }
+          const head = headerBuffer.slice(0, idx);
+          const status = /^HTTP\/1\.[01]\s+(\d{3})/.exec(head)?.[1];
+          if (status !== "200") {
+            lastError = `HTTP ${status ?? "?"}`;
+            socket.destroy();
+            return;
+          }
+          headerDone = true;
+          const body = Buffer.from(headerBuffer, "latin1").subarray(idx + 4);
+          totalBytes += body.byteLength;
+          windowBytes += body.byteLength;
+          headerBuffer = "";
+        } else {
+          totalBytes += chunk.byteLength;
+          windowBytes += chunk.byteLength;
+        }
+        if (Date.now() - started > durationMs) finish();
+      });
+      socket.on("end", () => {
+        if (sockets.every((s) => s.destroyed || s.readableEnded)) finish();
+      });
+      socket.on("close", () => {
+        if (sockets.every((s) => s.destroyed)) finish();
+      });
+    };
+    const ticker = setInterval(() => {
+      const now = Date.now();
+      const dt = (now - windowStart) / 1e3;
+      if (dt <= 0) return;
+      const bytes = windowBytes;
+      windowBytes = 0;
+      windowStart = now;
+      if (now - started < warmupMs) return;
+      const speed = bytes / dt / 1024 / 1024;
+      if (speed > peak) peak = speed;
+    }, windowMs);
+    const timer = setTimeout(finish, durationMs + 4e3);
+    for (let i = 0; i < connCount; i++) {
+      setTimeout(openOne, i * 60);
+    }
+  });
+}
+
+// src/countries.ts
+var COUNTRY_COLOS = {
+  HK: ["HKG"],
+  TW: ["TPE", "KHH"],
+  JP: ["NRT", "KIX", "CTS", "FUK"],
+  KR: ["ICN", "PUS"],
+  SG: ["SIN"],
+  MY: ["KUL"],
+  TH: ["BKK"],
+  VN: ["SGN", "HAN"],
+  ID: ["CGK", "DPS"],
+  PH: ["MNL"],
+  IN: ["BOM", "MAA", "DEL"],
+  AU: ["SYD", "MEL", "BNE", "PER"],
+  NZ: ["AKL"],
+  US: ["LAX", "SJC", "SEA", "ORD", "DFW", "IAD", "EWR", "ATL", "MIA", "DEN", "PHX", "BOS"],
+  CA: ["YYZ", "YVR", "YYC"],
+  GB: ["LHR", "MAN"],
+  DE: ["FRA", "MUC", "BER"],
+  FR: ["CDG", "MRS"],
+  NL: ["AMS"],
+  IT: ["MXP", "FCO"],
+  ES: ["MAD", "BCN"],
+  SE: ["ARN"],
+  CH: ["ZRH"],
+  AT: ["VIE"],
+  PL: ["WAW"],
+  RU: ["DME", "SVO"],
+  TR: ["IST"],
+  AE: ["DXB"],
+  IL: ["TLV"],
+  ZA: ["JNB"],
+  BR: ["GRU", "GIG"],
+  AR: ["EZE"],
+  CL: ["SCL"],
+  MX: ["MEX"]
+};
+var coloToCountry = /* @__PURE__ */ new Map();
+for (const [country, colos] of Object.entries(COUNTRY_COLOS)) {
+  for (const colo of colos) coloToCountry.set(colo, country);
+}
+function countryOfColo(colo) {
+  return coloToCountry.get(colo.toUpperCase()) ?? "";
+}
+function isKnownCountry(code) {
+  return Object.prototype.hasOwnProperty.call(COUNTRY_COLOS, code.toUpperCase());
+}
+var SUPPORTED_COUNTRIES = Object.keys(COUNTRY_COLOS);
+function normalizeCountryFilter(input) {
+  if (!Array.isArray(input)) return [];
+  const out = [];
+  for (const raw of input) {
+    const code = String(raw ?? "").trim().toUpperCase();
+    if (!code || out.includes(code)) continue;
+    if (isKnownCountry(code)) out.push(code);
+  }
+  return out;
+}
 
 // src/scan.ts
 async function tcpPing(ip, port, timeoutMs) {
   return new Promise((resolve) => {
     const started = Date.now();
     let settled = false;
-    const socket = new net.Socket();
+    const socket = new net2.Socket();
     const done = (ok) => {
       if (settled) return;
       settled = true;
@@ -574,13 +1041,65 @@ async function runScan(options) {
     return { ...item, probe: result };
   });
   const wsOk = probeResults.filter((r) => r.probe.ok);
-  const stage2 = wsOk.sort((a, b) => a.latency - b.latency).slice(0, speedLimit);
+  const countryFilter = normalizeCountryFilter(options.countries ?? []);
+  let wsFiltered = wsOk;
+  let appliedCountries = [];
+  if (countryFilter.length > 0 && wsOk.length > 0) {
+    const matched = wsOk.filter((r) => countryFilter.includes(countryOfColo(r.probe.colo || "")));
+    if (matched.length > 0) {
+      wsFiltered = matched;
+      appliedCountries = countryFilter;
+      report({
+        type: "progress",
+        stage: 2,
+        done: wsOk.length,
+        total: wsOk.length,
+        message: `\u56FD\u5BB6\u7B5B\u9009 ${countryFilter.join("/")}\uFF1A\u4FDD\u7559 ${matched.length}/${wsOk.length}\uFF0C\u8FDB\u5165\u6D4B\u901F`
+      });
+    } else {
+      report({
+        type: "progress",
+        stage: 2,
+        done: wsOk.length,
+        total: wsOk.length,
+        message: `\u56FD\u5BB6\u7B5B\u9009 ${countryFilter.join("/")} \u540E\u65E0\u5019\u9009\uFF0C\u5DF2\u5FFD\u7565\uFF08\u91C7\u6837\u592A\u5C0F\uFF1F\u8C03\u5230 500~1000 \u518D\u8BD5\uFF09`
+      });
+    }
+  }
+  const stage2 = wsFiltered.sort((a, b) => a.latency - b.latency).slice(0, speedLimit);
   let speedResults;
+  const speedMode = options.speedMode ?? "probe";
   if (options.skipSpeed) {
     report({ type: "stage", stage: 3, name: "\u8DF3\u8FC7\u6D4B\u901F\uFF08\u6309\u5EF6\u8FDF\u6392\u5E8F\uFF09", total: stage2.length });
     speedResults = stage2.map((r) => ({ ...r }));
+  } else if (speedMode === "url") {
+    report({ type: "stage", stage: 3, name: "\u771F\u5B9E\u4E0B\u884C\u901F\u5EA6\u6D4B\u8BD5\uFF08\u516C\u5F00\u6D4B\u901F\u5730\u5740\uFF09", total: stage2.length });
+    const parsedUrl = parseSpeedUrl(options.speedUrl ?? DEFAULT_SPEED_URL, schemeForPort(options.port));
+    const requestPath = withBytes(parsedUrl, options.speedBytes ?? 104857600);
+    let speedDone = 0;
+    speedResults = await pool(stage2, speedConcurrency, async (item) => {
+      const result = await measureThroughput({
+        ip: item.ip,
+        port: options.port,
+        sniHost: parsedUrl.host,
+        requestHost: parsedUrl.host,
+        path: requestPath,
+        connections: options.speedConnections ?? 3,
+        durationMs: options.speedDurationMs ?? 6e3,
+        timeoutMs: options.speedTimeoutMs ?? 2e4
+      });
+      speedDone++;
+      report({
+        type: "progress",
+        stage: 3,
+        done: speedDone,
+        total: stage2.length,
+        message: `\u6D4B\u901F ${speedDone}/${stage2.length} ${result.peakMBps.toFixed(1)} MB/s`
+      });
+      return { ...item, speed: result.ok ? result.peakMBps : 0 };
+    });
   } else {
-    report({ type: "stage", stage: 3, name: "\u771F\u5B9E\u4E0B\u884C\u901F\u5EA6\u6D4B\u8BD5", total: stage2.length });
+    report({ type: "stage", stage: 3, name: "\u771F\u5B9E\u4E0B\u884C\u901F\u5EA6\u6D4B\u8BD5\uFF08\u9879\u76EE\u63A2\u9488\u7AEF\u70B9\uFF09", total: stage2.length });
     let speedDone = 0;
     speedResults = await pool(stage2, speedConcurrency, async (item) => {
       const result = await measureDownload(
@@ -599,15 +1118,15 @@ async function runScan(options) {
         total: stage2.length,
         message: `\u6D4B\u901F ${speedDone}/${stage2.length} ${result.speedMBps.toFixed(1)} MB/s`
       });
-      return { ...item, download: result };
+      return { ...item, speed: result.ok ? result.speedMBps : 0 };
     });
   }
-  const entries = speedResults.filter((r) => options.skipSpeed ? true : Boolean(r.download && r.download.ok && r.download.speedMBps > 0)).map((r) => ({
+  const entries = speedResults.filter((r) => options.skipSpeed ? true : Boolean(r.speed && r.speed > 0)).map((r) => ({
     ip: r.ip,
     port: options.port,
     colo: r.probe.colo || "UNK",
     latency: r.latency,
-    speed: r.download ? Number(r.download.speedMBps.toFixed(2)) : 0
+    speed: r.speed ? Number(r.speed.toFixed(2)) : 0
   })).sort((a, b) => options.skipSpeed ? a.latency - b.latency : b.speed - a.speed || a.latency - b.latency).slice(0, top);
   for (const entry of entries) {
     report({ type: "result", entry });
@@ -619,7 +1138,9 @@ async function runScan(options) {
       tcpOk: tcpOk.length,
       wsOk: wsOk.length,
       speedOk: entries.length,
-      elapsedMs: Date.now() - started
+      elapsedMs: Date.now() - started,
+      countries: appliedCountries,
+      wsFiltered: wsFiltered.length
     }
   };
   report({ type: "done", count: entries.length });
@@ -857,6 +1378,8 @@ async function handleRequest(req, res) {
           host: body.host.trim(),
           port: body.port ?? 443,
           candidates: plan.candidates,
+          // 国家过滤（可多选）：不传 = 全量；无效代码在 normalizeCountryFilter 里被丢弃
+          countries: Array.isArray(body.countries) ? body.countries : void 0,
           top: body.top ?? 15,
           onProgress: (event) => broadcast(job, event)
         });
@@ -948,11 +1471,22 @@ scan \u9009\u9879:
   --no-callback          \u53EA\u6253\u5370\u7ED3\u679C\uFF0C\u4E0D\u56DE\u586B
   --path <path>          \u9636\u6BB5\u4E8C\u6821\u9A8C\u7684 WebSocket \u8DEF\u5F84\uFF0C\u9ED8\u8BA4 /__edge_probe
                          \uFF08\u5BF9\u63A5\u5176\u5B83\u9879\u76EE\u65F6\u586B\u5B83\u81EA\u5DF1\u7684 WS \u8DEF\u5F84\uFF0C\u4F8B\u5982 /vless \u6216 /<uuid>\uFF09
-  --probe-path <path>    \u9636\u6BB5\u4E09\u6D4B\u901F\u8DEF\u5F84\uFF0C\u9ED8\u8BA4 /__edge_probe
-  --no-speed             \u8DF3\u8FC7\u6D4B\u901F\uFF0C\u53EA\u6309\u5EF6\u8FDF\u6392\u5E8F\uFF08\u76EE\u6807\u6CA1\u6709 CFPilot \u63A2\u9488\u65F6\u7528\uFF09
+  --probe-path <path>    probe \u6A21\u5F0F\u7684\u6D4B\u901F\u8DEF\u5F84\uFF0C\u9ED8\u8BA4 /__edge_probe
+  --speed-mode <mode>    \u6D4B\u901F\u65B9\u5F0F\uFF1Aauto\uFF08\u9ED8\u8BA4\uFF09/ probe / url
+                         auto  = \u76EE\u6807\u6709\u63A2\u9488\u7AEF\u70B9\u5C31\u7528\u5B83\uFF0C\u5426\u5219\u81EA\u52A8\u6539\u7528\u516C\u5F00\u6D4B\u901F\u5730\u5740
+                         probe = \u53EA\u7528\u76EE\u6807\u9879\u76EE\u7684\u63A2\u9488\u7AEF\u70B9\uFF08\u6700\u5FE0\u5B9E\uFF0C\u8981\u6C42\u5BF9\u65B9\u6709\u8BE5\u7AEF\u70B9\uFF09
+                         url   = \u53EA\u7528\u516C\u5F00\u6D4B\u901F\u5730\u5740\uFF08\u4EFB\u4F55\u9879\u76EE\u90FD\u80FD\u6D4B\uFF09
+  --speed-url <url>      \u516C\u5F00\u6D4B\u901F\u5730\u5740\uFF0C\u9ED8\u8BA4 ${DEFAULT_SPEED_URL}
+                         \u53EF\u6362\u6210\u4EFB\u610F\u8FD4\u56DE\u5927\u6587\u4EF6\u7684\u5730\u5740
+  --speed-conns <n>      \u6D4B\u901F\u5E76\u53D1\u8FDE\u63A5\u6570\uFF0C\u9ED8\u8BA4 3
+                         \u5355\u6761 TCP \u8FDE\u63A5\u53D7\u62E5\u585E\u7A97\u53E3\u9650\u5236\uFF0C\u591A\u8FDE\u63A5\u66F4\u63A5\u8FD1\u771F\u5B9E\u5E26\u5BBD
+  --speed-duration <ms>  \u6D4B\u901F\u65F6\u957F\uFF0C\u9ED8\u8BA4 6000
+  --no-speed             \u8DF3\u8FC7\u6D4B\u901F\uFF0C\u53EA\u6309\u5EF6\u8FDF\u6392\u5E8F
   --top <n>              \u8FD4\u56DE\u6761\u6570\uFF0C\u9ED8\u8BA4 15
   --concurrency <n>      \u9636\u6BB5\u4E00\u5E76\u53D1\uFF0C\u9ED8\u8BA4 300
   --sample <n>           \u5019\u9009 IP \u91C7\u6837\u6570\uFF0C\u9ED8\u8BA4 20000
+  --countries <a,b>      \u56FD\u5BB6 / \u5730\u533A\u8FC7\u6EE4\uFF08\u53EF\u591A\u9009\uFF0C\u9017\u53F7\u5206\u9694\uFF0C\u5982 HK,JP,SG\uFF09
+                         \u4E0D\u9009 = \u5168\u91CF\u3002\u673A\u623F\u6765\u81EA 101 \u63E1\u624B\u54CD\u5E94\uFF1B\u7B5B\u5B8C\u4E3A\u7A7A\u4F1A\u81EA\u52A8\u5FFD\u7565
   --cidr <a,b>           \u81EA\u5B9A\u4E49\u7F51\u6BB5\uFF08\u53EF\u91CD\u590D\uFF0C\u7528\u9017\u53F7\u5206\u9694\uFF09
   --ip-file <path>       \u4F7F\u7528\u672C\u5730 IP \u5217\u8868\u6587\u4EF6
   --max-latency <ms>     \u9636\u6BB5\u4E00\u5EF6\u8FDF\u4E0A\u9650\uFF0C\u9ED8\u8BA4 0\uFF08\u4E0D\u9650\uFF09
@@ -972,6 +1506,35 @@ serve \u9009\u9879:
   ${NAME} scan --host cfpilot.example.com --token abc123
   ${NAME} serve
 `;
+function normalizeWsPath(raw, fallback) {
+  const value = (raw ?? fallback).trim();
+  if (!value) return fallback;
+  if (isMsysPollutedPath(value)) {
+    process.stderr.write(
+      `
+\u2717 --path \u88AB MSYS\uFF08Git-Bash\uFF09\u8F6C\u6362\u6210\u4E86 Windows \u8DEF\u5F84\uFF1A
+   \u6536\u5230\u7684\u662F\uFF1A${value}
+
+  \u8FD9\u662F Git-Bash \u7684\u81EA\u52A8\u8DEF\u5F84\u8F6C\u6362\u884C\u4E3A\uFF0C\u4E0D\u662F\u672C\u5DE5\u5177\u7684\u95EE\u9898\u3002
+  \u4E09\u79CD\u7ED5\u5F00\u65B9\u5F0F\uFF0C\u4EFB\u9009\u5176\u4E00\uFF1A
+    1. \u7528\u7B49\u53F7\u5199\u6CD5\uFF1A      --path=/vless
+    2. \u52A0\u73AF\u5883\u53D8\u91CF\uFF1A      MSYS_NO_PATHCONV=1 cfpilot-scanner scan ...
+    3. \u6362\u7528 PowerShell / CMD \u6267\u884C
+`
+    );
+    process.exit(1);
+  }
+  if (!value.startsWith("/")) {
+    process.stderr.write(
+      `
+\u2717 --path \u5FC5\u987B\u4EE5 / \u5F00\u5934\uFF0C\u6536\u5230\u7684\u662F\uFF1A\u300C${value}\u300D
+  \u4F8B\u5982\uFF1A--path /vless \u6216 --path /\uFF08\u76EE\u6807\u9879\u76EE\u7528\u6839\u8DEF\u5F84\u65F6\uFF09
+`
+    );
+    process.exit(1);
+  }
+  return value;
+}
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   const command = args.command && !args.command.startsWith("-") ? args.command : "";
@@ -1097,9 +1660,10 @@ async function commandScan(args) {
   const top = flagNumber(args, "top", 15);
   const token = flagString(args, "token");
   const noCallback = flagBool(args, "no-callback");
-  const wsPath = flagString(args, "path", "/__edge_probe");
-  const probePath = flagString(args, "probe-path", "/__edge_probe");
+  const wsPath = normalizeWsPath(flagString(args, "path"), "/__edge_probe");
+  const probePath = normalizeWsPath(flagString(args, "probe-path"), "/__edge_probe");
   const noSpeed = flagBool(args, "no-speed");
+  const countries = normalizeCountryFilter(flagList(args, "countries"));
   const callback = noCallback ? "" : flagString(args, "callback", token ? `https://${host}/api/v1/preferred-ips` : "");
   if (!quiet) {
     process.stdout.write(`
@@ -1107,8 +1671,31 @@ ${NAME} v${VERSION}
 `);
     process.stdout.write(`\u76EE\u6807\u57DF\u540D\uFF1A${host}:${port}\uFF08\u5C06\u4F5C\u4E3A TLS SNI \u4E0E HTTP Host\uFF09
 `);
-    process.stdout.write("\u6B63\u5728\u51C6\u5907 Cloudflare \u7F51\u6BB5\u2026\n");
+    process.stdout.write(`WS \u8DEF\u5F84\uFF1A${wsPath}
+`);
+    if (countries.length > 0) {
+      process.stdout.write(`\u56FD\u5BB6\u7B5B\u9009\uFF1A${countries.join(" / ")}\uFF08\u4E0D\u586B\u5219\u5168\u91CF\uFF09
+`);
+    }
+  }
+  if (!quiet) {
+    const env = await detectProxyInterference(host);
+    if (!env.clean) {
+      process.stdout.write("\n\u26A0\uFE0F  \u68C0\u6D4B\u5230\u53EF\u80FD\u5E72\u6270\u4F18\u9009\u7684\u56E0\u7D20\uFF1A\n");
+      for (const f of env.findings) {
+        process.stdout.write(`   ${f.message}
+`);
+        process.stdout.write(`   \u2192 ${f.advice}
+`);
+      }
+      process.stdout.write("\n   \u4F18\u9009\u6D4B\u7684\u662F\u300C\u672C\u673A\u76F4\u8FDE\u8BE5 IP\u300D\u7684\u771F\u5B9E\u8D28\u91CF\u3002\n");
+      process.stdout.write("   \u6D41\u91CF\u88AB\u4EE3\u7406\u63A5\u7BA1\u65F6\uFF0C\u7ED3\u679C\u770B\u8D77\u6765\u6B63\u5E38\uFF0C\u4F46\u6240\u6709 IP \u6210\u7EE9\u8D8B\u4E8E\u4E00\u81F4\uFF0C\n");
+      process.stdout.write("   \u5BFC\u5165\u5BA2\u6237\u7AEF\u540E\u5927\u91CF -1\uFF08\u56E0\u4E3A\u4ECE\u672A\u771F\u6B63\u76F4\u8FDE\u9A8C\u8BC1\u8FC7\uFF09\u3002\n");
+      process.stdout.write("   \u2192 \u5EFA\u8BAE\u5173\u95ED\u4EE3\u7406\u5DE5\u5177\uFF08\u542B TUN \u6A21\u5F0F\u4E0E\u7CFB\u7EDF\u4EE3\u7406\uFF09\u540E\u91CD\u8DD1\u3002\n");
+      process.stdout.write("   \u2192 \u6216\u628A\u672C\u7A0B\u5E8F\u4E0E\u5F85\u6D4B IP \u6BB5\u8BBE\u4E3A\u76F4\u8FDE\u3002\n\n");
+    }
   }
+  if (!quiet) process.stdout.write("\u6B63\u5728\u51C6\u5907 Cloudflare \u7F51\u6BB5\u2026\n");
   const candidates = await resolveCandidatesFromArgs(args);
   if (candidates.length === 0) {
     process.stderr.write("\u5019\u9009 IP \u4E3A\u7A7A\uFF0C\u8BF7\u68C0\u67E5 --ip-file / --cidr \u53C2\u6570\n");
@@ -1117,27 +1704,51 @@ ${NAME} v${VERSION}
   if (!quiet) process.stdout.write(`\u5019\u9009 IP\uFF1A${candidates.length} \u4E2A
 `);
   let skipSpeed = noSpeed;
+  let speedMode = "probe";
+  let speedUrl = flagString(args, "speed-url", DEFAULT_SPEED_URL);
   if (!skipSpeed) {
-    try {
-      const probe = await fetch(`https://${host}${probePath}?bytes=1024`, {
-        method: "GET",
-        signal: AbortSignal.timeout(8e3)
-      });
-      if (!probe.headers.get("x-probe-bytes")) {
-        skipSpeed = true;
+    const forcedMode = flagString(args, "speed-mode");
+    if (forcedMode === "url") {
+      speedMode = "url";
+      if (!quiet) process.stdout.write(`\u6D4B\u901F\u65B9\u5F0F\uFF1A\u516C\u5F00\u6D4B\u901F\u5730\u5740\uFF08${speedUrl}\uFF09
+`);
+    } else if (forcedMode === "probe") {
+      speedMode = "probe";
+    } else {
+      let hasProbe = false;
+      try {
+        const probe = await fetch(`https://${host}${probePath}?bytes=1024`, {
+          method: "GET",
+          signal: AbortSignal.timeout(8e3)
+        });
+        hasProbe = Boolean(probe.headers.get("x-probe-bytes"));
+      } catch {
+        hasProbe = false;
+      }
+      if (hasProbe) {
+        speedMode = "probe";
+        if (!quiet) process.stdout.write("\u6D4B\u901F\u65B9\u5F0F\uFF1A\u9879\u76EE\u63A2\u9488\u7AEF\u70B9\uFF08\u6700\u5FE0\u5B9E\uFF09\n");
+      } else {
+        speedMode = "url";
         if (!quiet) {
-          process.stdout.write("\n\u63D0\u793A\uFF1A" + probePath + " \u4E0D\u662F CFPilot \u63A2\u9488\u7AEF\u70B9\uFF0C\u5DF2\u8DF3\u8FC7\u6D4B\u901F\uFF08\u53EA\u6309\u5EF6\u8FDF\u6392\u5E8F\uFF09\n");
-          process.stdout.write("      \u5982\u9700\u6D4B\u901F\uFF0C\u8BF7\u7528 --probe-path \u6307\u5B9A\u76EE\u6807\u9879\u76EE\u7684\u6D4B\u901F\u8DEF\u5F84\n");
+          process.stdout.write(`
+\u63D0\u793A\uFF1A${probePath} \u4E0D\u662F CFPilot \u63A2\u9488\u7AEF\u70B9\uFF0C\u6539\u7528\u516C\u5F00\u6D4B\u901F\u5730\u5740\u6D4B\u901F
+`);
+          process.stdout.write("      \uFF08\u4ECD\u4F1A\u5148\u505A 101 \u6821\u9A8C\uFF0C\u56E0\u6B64\u4E0D\u4F1A\u9009\u51FA\u8FDE\u4E0D\u4E0A\u7684 IP\uFF09\n");
         }
+        speedUrl = await pickAvailableSpeedUrl(
+          [speedUrl, ...SPEED_URL_PRESETS.map((p) => p.url)],
+          quiet ? void 0 : (m) => process.stdout.write(`      ${m}
+`)
+        );
       }
-    } catch {
-      skipSpeed = true;
     }
   }
   const summary = await runScan({
     host,
     port,
     candidates,
+    countries,
     wsPath,
     probePath,
     skipSpeed,
@@ -1149,6 +1760,10 @@ ${NAME} v${VERSION}
     speedLimit: flagNumber(args, "speed-limit", 30),
     speedTimeoutMs: flagNumber(args, "speed-timeout", 12e3),
     speedBytes: flagNumber(args, "speed-bytes", 5 * 1024 * 1024),
+    speedMode,
+    speedUrl,
+    speedConnections: flagNumber(args, "speed-conns", 3),
+    speedDurationMs: flagNumber(args, "speed-duration", 6e3),
     top,
     onProgress: (event) => printProgress(event, quiet)
   });

package/package.json

@@ -1,41 +1,41 @@
-{
-  "name": "cfpilot-scanner",
-  "version": "0.2.0",
-  "description": "CFPilot 优选器：用你自己的域名做 WebSocket 101 真连接校验，只保留真正可用的 Cloudflare IP；兼容任意 VLESS-WS 项目",
-  "license": "MIT",
-  "author": "CFPilot Contributors",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/xmwengxing/CFPilot.git"
-  },
-  "keywords": [
-    "cloudflare",
-    "ip",
-    "optimize",
-    "scanner",
-    "vless",
-    "websocket",
-    "cfpilot"
-  ],
-  "type": "module",
-  "bin": {
-    "cfpilot-scanner": "dist/cli.js"
-  },
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "engines": {
-    "node": ">=18.17.0"
-  },
-  "scripts": {
-    "build": "node scripts/build.mjs",
-    "typecheck": "tsc --noEmit -p tsconfig.json",
-    "prepublishOnly": "npm run build"
-  },
-  "devDependencies": {
-    "@types/node": "^26.6.5",
-    "esbuild": "^0.28.2",
-    "typescript": "^5.9.3"
-  }
-}
+{
+  "name": "cfpilot-scanner",
+  "version": "0.3.0",
+  "description": "CFPilot 优选器：用你自己的域名做 WebSocket 101 真连接校验，只保留真正可用的 Cloudflare IP；兼容任意 VLESS-WS 项目",
+  "license": "MIT",
+  "author": "CFPilot Contributors",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xmwengxing/CFPilot.git"
+  },
+  "keywords": [
+    "cloudflare",
+    "ip",
+    "optimize",
+    "scanner",
+    "vless",
+    "websocket",
+    "cfpilot"
+  ],
+  "type": "module",
+  "bin": {
+    "cfpilot-scanner": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.17.0"
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.5",
+    "esbuild": "^0.28.2",
+    "typescript": "^5.9.3"
+  }
+}