cfpilot-scanner 0.1.0 → 0.3.0

package/README.md

@@ -1,89 +1,198 @@
-# cfpilot-scanner
-
-**CFPilot 本地真连接优选器** —— 用你自己的 Worker 域名做 SNI/Host，完成
-**WebSocket 101 真连接校验**，只保留真正能连通的 Cloudflare 优选 IP，
-彻底消灭客户端里的 `-1`。
-
-> 绝大多数"优选 IP"工具只做 TCP 握手（端口通就算可用），
-> 结果填进客户端大量 `-1`。本工具会真的发起 TLS + WebSocket 升级，
-> 走完你自己 Worker 的入站路径，只有返回 `101` 的 IP 才会被保留。
-
-## 安装
-
-```bash
-npx -y cfpilot-scanner --help
-```
-
-无需安装，`npx` 直接运行；也可 `npm i -g cfpilot-scanner`。
-
-## 快速开始
-
-```bash
-# 1. 在你的面板里生成一次性扫描令牌（有效期短，用完即废）
-# 2. 执行优选（域名必须是绑好自定义域名的那个）
-npx -y cfpilot-scanner scan --host cfpilot.example.com --token <令牌>
-
-# 结果会自动回填到面板的「手动优选 IP」池
-```
-
-只打印不回填：
-
-```bash
-npx -y cfpilot-scanner scan --host cfpilot.example.com --no-callback --top 20
-```
-
-## 三阶扫描
-
-| 阶段 | 做什么 | 默认开销 |
-|------|--------|----------|
-| 一阶 · 延迟探测 | 采样大量 IP 做 TCP 连接测延迟 | 采样 20000，并发 300 |
-| 二阶 · 真连接校验 | 对候选发起 **TLS + WebSocket 101** 握手 | 120 个候选 |
-| 三阶 · 下行测速 | 通过 `/__edge_probe` 流式下载测真实速度 | 30 个候选，5 MB |
-
-只有通过二阶的 IP 才算"可用"，三阶用于排序。
-
-## 常用参数
-
-```
---host <domain>       你的 Worker 自定义域名（SNI 与 Host）
---token <token>       面板生成的一次性令牌
---top <n>             保留条数（默认 15）
---concurrency <n>     一阶并发（默认 300）
---sample <n>          候选采样数（默认 20000）
---cidr <a,b>          自定义网段
---ip-file <path>      使用本地 IP 列表（支持 CloudflareSpeedTest 的 result.csv）
---max-latency <ms>    一阶延迟上限
---json                以 JSON 输出
-```
-
-## 本地面板桥接
-
-```bash
-npx -y cfpilot-scanner serve
-```
-
-在 `127.0.0.1:19527` 起一个本地服务，面板里点「本地真连接优选」会自动唤醒它，
-通过 SSE 实时推送进度，不需要手动复制令牌。
-
-## 输出示例
-
-```
-阶段一：采样 20000 个候选，并发 300 …
-阶段二：120 个候选进入 101 校验 …
-阶段三：30 个候选测速（5 MB）…
-✅ 可用 14 个，已回填面板
-
-  104.17.242.168:443   12ms   18.4 MB/s
-  104.19.73.179:443    18ms   15.1 MB/s
-  ...
-```
-
-## 为什么需要它
-
-随机抽取的 Cloudflare 官方 IP 里，能真正完成 WebSocket 升级的比例只有约 1/4，
-而且**因地区、运营商、时间而异**。只有用你自己的域名实测过，
-才能得到当前网络下真正可用的那批 IP。
-
-## 许可
-
-MIT
+# cfpilot-scanner
+
+**CFPilot 本地真连接优选器** —— 用你自己的 Worker 域名做 SNI/Host，完成
+**WebSocket 101 真连接校验**，只保留真正能连通的 Cloudflare 优选 IP，
+彻底消灭客户端里的 `-1`。
+
+> 绝大多数"优选 IP"工具只做 TCP 握手（端口通就算可用），
+> 结果填进客户端大量 `-1`。本工具会真的发起 TLS + WebSocket 升级，
+> 走完你自己 Worker 的入站路径，只有返回 `101` 的 IP 才会被保留。
+
+## 安装
+
+```bash
+npx -y cfpilot-scanner --help
+```
+
+无需安装，`npx` 直接运行；也可 `npm i -g cfpilot-scanner`。
+
+## 快速开始
+
+```bash
+# 1. 在你的面板里生成一次性扫描令牌（有效期短，用完即废）
+# 2. 执行优选（域名必须是绑好自定义域名的那个）
+npx -y cfpilot-scanner scan --host cfpilot.example.com --token <令牌>
+
+# 结果会自动回填到面板的「手动优选 IP」池
+```
+
+只打印不回填：
+
+```bash
+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 路径**即可：
+
+```bash
+# CFNext：路径通常就是 UUID（或面板里配置的 path）
+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 才算可用
+- **测速支持任意项目**，不需要对方提供任何端点（见下节）
+- 想控制行为可用 `--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`）
+   太短会被慢启动拉低，太长浪费时间。
+
+## 输出：直接可复制的列表
+
+扫描结束后会额外打印一段，**一行一个，直接粘进同类项目的「自定义 IP / 优选 IP」输入框**：
+
+```
+── 可直接复制（粘贴到「自定义 IP / 优选 IP」输入框）──
+104.19.73.179:443#LAX
+104.17.242.168:443#LAX
+104.16.59.243:443#LAX
+104.27.19.224:443#AMS
+```
+
+（`IP:端口#机房` 是这类项目通用的语法；优选几个就有几行，不用再手动删改）
+
+## 三阶扫描
+
+| 阶段 | 做什么 | 默认开销 |
+|------|--------|----------|
+| 一阶 · 延迟探测 | 采样大量 IP 做 TCP 连接测延迟 | 采样 20000，并发 300 |
+| 二阶 · 真连接校验 | 对候选发起 **TLS + WebSocket 101** 握手 | 120 个候选 |
+| 三阶 · 下行测速 | 通过 `/__edge_probe` 流式下载测真实速度 | 30 个候选，5 MB |
+
+只有通过二阶的 IP 才算"可用"，三阶用于排序。
+
+## 常用参数
+
+```
+--host <domain>       你的 Worker 自定义域名（SNI 与 Host）
+--token <token>       面板生成的一次性令牌
+--top <n>             保留条数（默认 15）
+--concurrency <n>     一阶并发（默认 300）
+--sample <n>          候选采样数（默认 20000）
+--cidr <a,b>          自定义网段
+--ip-file <path>      使用本地 IP 列表（支持 CloudflareSpeedTest 的 result.csv）
+--max-latency <ms>    一阶延迟上限
+--json                以 JSON 输出
+```
+
+## 本地面板桥接
+
+```bash
+npx -y cfpilot-scanner serve
+```
+
+在 `127.0.0.1:19527` 起一个本地服务，面板里点「本地真连接优选」会自动唤醒它，
+通过 SSE 实时推送进度，不需要手动复制令牌。
+
+## 输出示例
+
+```
+阶段一：采样 20000 个候选，并发 300 …
+阶段二：120 个候选进入 101 校验 …
+阶段三：30 个候选测速（5 MB）…
+✅ 可用 14 个，已回填面板
+
+  104.17.242.168:443   12ms   18.4 MB/s
+  104.19.73.179:443    18ms   15.1 MB/s
+  ...
+```
+
+## 为什么需要它
+
+随机抽取的 Cloudflare 官方 IP 里，能真正完成 WebSocket 升级的比例只有约 1/4，
+而且**因地区、运营商、时间而异**。只有用你自己的域名实测过，
+才能得到当前网络下真正可用的那批 IP。
+
+## 许可
+
+MIT

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,18 +363,246 @@ 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) {
   const match = /cf-ray:\s*[0-9a-f]+-([A-Z]{3})/i.exec(text);
   return match ? match[1].toUpperCase() : "";
 }
-function probeWs101(ip, port, host, timeoutMs = 3e3) {
+function probeWs101(ip, port, host, timeoutMs = 3e3, path = "/__edge_probe") {
   return new Promise((resolve) => {
     const started = Date.now();
     const key = crypto.randomBytes(16).toString("base64");
@@ -354,7 +619,7 @@ function probeWs101(ip, port, host, timeoutMs = 3e3) {
       resolve({ ...result, latencyMs: Date.now() - started });
     };
     const request = [
-      `GET /__edge_probe HTTP/1.1`,
+      `GET ${path} HTTP/1.1`,
       `Host: ${host}`,
       `Upgrade: websocket`,
       `Connection: Upgrade`,
@@ -364,7 +629,7 @@ function probeWs101(ip, port, host, timeoutMs = 3e3) {
       "",
       ""
     ].join("\r\n");
-    const socket = tls.connect(
+    const socket = tls2.connect(
       {
         host: ip,
         port,
@@ -405,7 +670,7 @@ function probeWs101(ip, port, host, timeoutMs = 3e3) {
     });
   });
 }
-function measureDownload(ip, port, host, bytes, timeoutMs = 12e3) {
+function measureDownload(ip, port, host, bytes, timeoutMs = 12e3, path = "/__edge_probe") {
   return new Promise((resolve) => {
     const started = Date.now();
     let headerEnd = -1;
@@ -423,14 +688,14 @@ function measureDownload(ip, port, host, bytes, timeoutMs = 12e3) {
       resolve({ ...result, ms: Date.now() - started });
     };
     const request = [
-      `GET /__edge_probe?bytes=${bytes} HTTP/1.1`,
+      `GET ${path}?bytes=${bytes} HTTP/1.1`,
       `Host: ${host}`,
       `User-Agent: ${USER_AGENT}`,
       `Accept: */*`,
       "",
       ""
     ].join("\r\n");
-    const socket = tls.connect(
+    const socket = tls2.connect(
       {
         host: ip,
         port,
@@ -463,6 +728,11 @@ function measureDownload(ip, port, host, bytes, timeoutMs = 12e3) {
     socket.on("error", (err) => {
       finish({ ok: false, bytes: received, speedMBps: 0, error: err.message });
     });
+    const settle = () => {
+      if (settled) return;
+      const seconds = Math.max(1e-3, (Date.now() - started) / 1e3);
+      finish({ ok: received > 0, bytes: received, speedMBps: received / 1024 / 1024 / seconds });
+    };
     socket.on("data", (chunk) => {
       if (headerEnd < 0) {
         buffer += chunk.toString("latin1");
@@ -475,19 +745,224 @@ function measureDownload(ip, port, host, bytes, timeoutMs = 12e3) {
         const body = Buffer.from(buffer, "latin1").subarray(headerEnd);
         received += body.byteLength;
         headerEnd = 0;
-        return;
+      } else {
+        received += chunk.byteLength;
       }
-      received += chunk.byteLength;
+      if (received >= bytes) settle();
     });
+    socket.on("end", settle);
+    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;
@@ -554,7 +1029,7 @@ async function runScan(options) {
   report({ type: "stage", stage: 2, name: "WebSocket 101 \u771F\u8FDE\u63A5\u6821\u9A8C", total: stage1.length });
   let probeDone = 0;
   const probeResults = await pool(stage1, probeConcurrency, async (item) => {
-    const result = await probeWs101(item.ip, options.port, options.host, probeTimeoutMs);
+    const result = await probeWs101(item.ip, options.port, options.host, probeTimeoutMs, options.wsPath ?? "/__edge_probe");
     probeDone++;
     report({
       type: "progress",
@@ -566,34 +1041,93 @@ 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);
-  report({ type: "stage", stage: 3, name: "\u771F\u5B9E\u4E0B\u884C\u901F\u5EA6\u6D4B\u8BD5", total: stage2.length });
-  let speedDone = 0;
-  const speedResults = await pool(stage2, speedConcurrency, async (item) => {
-    const result = await measureDownload(
-      item.ip,
-      options.port,
-      options.host,
-      speedBytes,
-      speedTimeoutMs
-    );
-    speedDone++;
-    report({
-      type: "progress",
-      stage: 3,
-      done: speedDone,
-      total: stage2.length,
-      message: `\u6D4B\u901F ${speedDone}/${stage2.length} ${result.speedMBps.toFixed(1)} MB/s`
+  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 };
     });
-    return { ...item, download: result };
-  });
-  const entries = speedResults.filter((r) => r.download.ok && r.download.speedMBps > 0).map((r) => ({
+  } else {
+    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(
+        item.ip,
+        options.port,
+        options.host,
+        speedBytes,
+        speedTimeoutMs,
+        options.probePath ?? "/__edge_probe"
+      );
+      speedDone++;
+      report({
+        type: "progress",
+        stage: 3,
+        done: speedDone,
+        total: stage2.length,
+        message: `\u6D4B\u901F ${speedDone}/${stage2.length} ${result.speedMBps.toFixed(1)} MB/s`
+      });
+      return { ...item, speed: result.ok ? result.speedMBps : 0 };
+    });
+  }
+  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: Number(r.download.speedMBps.toFixed(1))
-  })).sort((a, b) => b.speed - a.speed || a.latency - b.latency).slice(0, top);
+    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 });
   }
@@ -604,12 +1138,17 @@ 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 });
   return summary;
 }
+function formatCopyable(entries) {
+  return entries.map((e) => `${e.ip}:${e.port}#${e.colo}`).join("\n");
+}
 function formatEntries(entries) {
   return entries.map((e) => `${e.ip}:${e.port}#${e.colo}_${e.latency}_${e.speed}`);
 }
@@ -639,7 +1178,7 @@ async function postResults(callbackUrl, token, entries, timeoutMs = 15e3) {
 
 // src/server.ts
 import { createServer } from "node:http";
-var BRIDGE_VERSION = "0.1.0";
+var BRIDGE_VERSION = "0.2.0";
 var DEFAULT_BRIDGE_PORT = 19527;
 function normalizeSample(value) {
   if (typeof value === "number" && Number.isFinite(value) && value > 0) {
@@ -839,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)
         });
@@ -906,7 +1447,7 @@ async function handleRequest(req, res) {
 }
 
 // src/version.ts
-var VERSION = "0.1.0";
+var VERSION = "0.2.0";
 var NAME = "cfpilot-scanner";
 
 // src/cli.ts
@@ -928,9 +1469,24 @@ scan \u9009\u9879:
   --token <token>        \u56DE\u586B\u4EE4\u724C\uFF08\u9762\u677F\u751F\u6210\u7684\u4E00\u6B21\u6027\u4EE4\u724C\u6216 SCANNER_TOKEN\uFF09
   --callback <url>       \u56DE\u586B\u5730\u5740\uFF0C\u9ED8\u8BA4 https://<host>/api/v1/preferred-ips
   --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>    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
@@ -950,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 : "";
@@ -1057,6 +1642,11 @@ function printTable(entries) {
 `);
   });
 }
+function printCopyable(entries) {
+  if (entries.length === 0) return;
+  process.stdout.write("\n\u2500\u2500 \u53EF\u76F4\u63A5\u590D\u5236\uFF08\u7C98\u8D34\u5230\u300C\u81EA\u5B9A\u4E49 IP / \u4F18\u9009 IP\u300D\u8F93\u5165\u6846\uFF09\u2500\u2500\n");
+  process.stdout.write(formatCopyable(entries) + "\n");
+}
 async function commandScan(args) {
   const host = flagString(args, "host");
   const quiet = flagBool(args, "quiet");
@@ -1070,6 +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 = 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(`
@@ -1077,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");
@@ -1086,10 +1703,55 @@ ${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) {
+    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(`
+\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}
+`)
+        );
+      }
+    }
+  }
   const summary = await runScan({
     host,
     port,
     candidates,
+    countries,
+    wsPath,
+    probePath,
+    skipSpeed,
     concurrency: flagNumber(args, "concurrency", 300),
     tcpTimeoutMs: flagNumber(args, "timeout", 1200),
     maxLatencyMs: flagNumber(args, "max-latency", 0),
@@ -1098,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)
   });
@@ -1108,6 +1774,7 @@ ${NAME} v${VERSION}
     );
   } else {
     printTable(summary.entries);
+    printCopyable(summary.entries);
   }
   if (callback && token) {
     const result = await postResults(callback, token, formatEntries(summary.entries));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cfpilot-scanner",
-  "version": "0.1.0",
-  "description": "CFPilot 本地真连接优选器：用你自己的 Worker 域名做 SNI/Host 完成 WebSocket 101 真连接校验，彻底消灭 -1 节点",
+  "version": "0.3.0",
+  "description": "CFPilot 优选器：用你自己的域名做 WebSocket 101 真连接校验，只保留真正可用的 Cloudflare IP；兼容任意 VLESS-WS 项目",
   "license": "MIT",
   "author": "CFPilot Contributors",
   "repository": {