cfpilot-scanner 0.4.0 → 0.6.4

package/README.md

@@ -1,198 +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
-```
-
-## 运行前必须关闭代理工具
-
-> ⚠️ 这是最容易踩的坑，也是「结果看起来正常但导入客户端全是 -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
+# 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

@@ -406,69 +406,6 @@ function readIpFile(text) {
   return out;
 }
 
-// src/candidates.ts
-var DEFAULT_CANDIDATE_SAMPLE = 2e4;
-var DEFAULT_CANDIDATE_SEED = 24301;
-var DEFAULT_BRIDGE_SAMPLE = 6556;
-function normalizeCidrInput(cidr) {
-  if (cidr === void 0) return [];
-  const list = Array.isArray(cidr) ? cidr : [cidr];
-  const out = [];
-  for (const item of list) {
-    if (typeof item !== "string") continue;
-    for (const part of item.split(/[\n,]+/)) {
-      const value = part.trim();
-      if (value) out.push(value);
-    }
-  }
-  return out;
-}
-function isIpv6Cidr(cidr) {
-  return cidr.includes(":");
-}
-function filterByFamily(cidrs, family) {
-  if (family === "both") return cidrs;
-  const wantIpv6 = family === "v6";
-  return cidrs.filter((cidr) => isIpv6Cidr(cidr) === wantIpv6);
-}
-async function loadCloudflareCidrs(family) {
-  let ipv4 = BUILTIN_IPV4_CIDRS;
-  let ipv6 = BUILTIN_IPV6_CIDRS;
-  try {
-    const ranges = await fetchCloudflareCidrs();
-    if (ranges.ipv4.length > 0) ipv4 = ranges.ipv4;
-    if (ranges.ipv6.length > 0) ipv6 = ranges.ipv6;
-  } catch {
-  }
-  if (family === "v4") return [...ipv4];
-  if (family === "v6") return [...ipv6];
-  return [...ipv4, ...ipv6];
-}
-async function resolveCandidates(opts = {}) {
-  const sample = opts.sample ?? DEFAULT_CANDIDATE_SAMPLE;
-  const seed = opts.seed ?? DEFAULT_CANDIDATE_SEED;
-  const family = opts.family ?? "both";
-  const customCidrs = normalizeCidrInput(opts.cidr);
-  if (customCidrs.length > 0) {
-    return expandCidrs(filterByFamily(customCidrs, family), { sample, seed });
-  }
-  const cidrs = await loadCloudflareCidrs(family);
-  return expandCidrs(cidrs, { sample, seed });
-}
-function normalizeCandidateList(input) {
-  if (!Array.isArray(input) || input.length === 0) return [];
-  const lines = input.filter((item) => typeof item === "string");
-  if (lines.length === 0) return [];
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const ip of readIpFile(lines.join("\n"))) {
-    if (seen.has(ip)) continue;
-    seen.add(ip);
-    out.push(ip);
-  }
-  return out;
-}
-
 // src/net-env.ts
 import * as net from "node:net";
 import { execFile } from "node:child_process";
@@ -532,6 +469,44 @@ function isFakeIp(ip) {
   const [a, b] = parts;
   return a === 198 && (b === 18 || b === 19);
 }
+function isPublicAddress(ip) {
+  const value = ip.trim();
+  if (!value) return false;
+  if (!value.includes(":")) {
+    const parts = value.split(".");
+    if (parts.length !== 4) return false;
+    const nums = [];
+    for (const p of parts) {
+      if (!/^\d{1,3}$/.test(p)) return false;
+      const n = Number(p);
+      if (n > 255) return false;
+      nums.push(n);
+    }
+    const [a, b] = nums;
+    if (a === 0) return false;
+    if (a === 10) return false;
+    if (a === 127) return false;
+    if (a >= 224) return false;
+    if (a === 169 && b === 254) return false;
+    if (a === 172 && b >= 16 && b <= 31) return false;
+    if (a === 192 && b === 168) return false;
+    if (a === 100 && b >= 64 && b <= 127) return false;
+    if (a === 198 && (b === 18 || b === 19)) return false;
+    return true;
+  }
+  const lower = value.toLowerCase();
+  if (lower.startsWith("::ffff:") && lower.includes(".")) {
+    return isPublicAddress(lower.slice(7));
+  }
+  const groups = lower.split(":");
+  if (groups.length < 3) return false;
+  const first = groups[0];
+  if (!/^[0-9a-f]{1,4}$/.test(first)) return false;
+  const firstByte = Number.parseInt(first.slice(0, 2).padEnd(2, "0"), 16);
+  if (firstByte < 32 || firstByte > 63) return false;
+  if (lower.startsWith("2001:db8:")) return false;
+  return true;
+}
 async function detectProxyInterference(host) {
   const findings = [];
   const listening = [];
@@ -574,6 +549,74 @@ function isMsysPollutedPath(value) {
   return looksWindows || hasMsysHint;
 }
 
+// src/candidates.ts
+var DEFAULT_CANDIDATE_SAMPLE = 2e4;
+var DEFAULT_CANDIDATE_SEED = 24301;
+var DEFAULT_BRIDGE_SAMPLE = 6556;
+function normalizeCidrInput(cidr) {
+  if (cidr === void 0) return [];
+  const list = Array.isArray(cidr) ? cidr : [cidr];
+  const out = [];
+  for (const item of list) {
+    if (typeof item !== "string") continue;
+    for (const part of item.split(/[\n,]+/)) {
+      const value = part.trim();
+      if (value) out.push(value);
+    }
+  }
+  return out;
+}
+function isIpv6Cidr(cidr) {
+  return cidr.includes(":");
+}
+function filterByFamily(cidrs, family) {
+  if (family === "both") return cidrs;
+  const wantIpv6 = family === "v6";
+  return cidrs.filter((cidr) => isIpv6Cidr(cidr) === wantIpv6);
+}
+async function loadCloudflareCidrs(family) {
+  let ipv4 = BUILTIN_IPV4_CIDRS;
+  let ipv6 = BUILTIN_IPV6_CIDRS;
+  try {
+    const ranges = await fetchCloudflareCidrs();
+    if (ranges.ipv4.length > 0) ipv4 = ranges.ipv4;
+    if (ranges.ipv6.length > 0) ipv6 = ranges.ipv6;
+  } catch {
+  }
+  if (family === "v4") return [...ipv4];
+  if (family === "v6") return [...ipv6];
+  return [...ipv4, ...ipv6];
+}
+async function resolveCandidates(opts = {}) {
+  const sample = opts.sample ?? DEFAULT_CANDIDATE_SAMPLE;
+  const seed = opts.seed ?? DEFAULT_CANDIDATE_SEED;
+  const family = opts.family ?? "both";
+  const customCidrs = normalizeCidrInput(opts.cidr);
+  if (customCidrs.length > 0) {
+    return expandCidrs(filterByFamily(customCidrs, family), { sample, seed });
+  }
+  const cidrs = await loadCloudflareCidrs(family);
+  return expandCidrs(cidrs, { sample, seed });
+}
+function normalizeCandidateList(input) {
+  if (!Array.isArray(input) || input.length === 0) return [];
+  const lines = input.filter((item) => typeof item === "string");
+  if (lines.length === 0) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const ip of readIpFile(lines.join("\n"))) {
+    if (seen.has(ip)) continue;
+    seen.add(ip);
+    const isIpv4Literal = /^\d{1,3}(\.\d{1,3}){3}$/.test(ip);
+    const isIpv6Literal = ip.includes(":");
+    if (isIpv4Literal || isIpv6Literal) {
+      if (!isPublicAddress(ip)) continue;
+    }
+    out.push(ip);
+  }
+  return out;
+}
+
 // src/speed-url.ts
 import * as tls from "node:tls";
 var SPEED_URL_PRESETS = [
@@ -1307,10 +1350,20 @@ async function pool(items, concurrency, worker) {
   await Promise.all(runners);
   return out;
 }
+async function withRetry(attempts, fn, isOk = (r) => r.ok === true) {
+  const total = Math.max(1, Math.floor(attempts));
+  let last;
+  for (let i = 0; i < total; i++) {
+    last = await fn();
+    if (isOk(last)) return last;
+  }
+  return last;
+}
 async function runScan(options) {
   const started = Date.now();
   const concurrency = options.concurrency ?? 300;
   const tcpTimeoutMs = options.tcpTimeoutMs ?? 1200;
+  const retries = options.retries ?? 2;
   const tlsConcurrency = options.tlsConcurrency ?? 64;
   const tlsTimeoutMs = options.tlsTimeoutMs ?? 4e3;
   const maxLatencyMs = options.maxLatencyMs ?? 0;
@@ -1328,7 +1381,7 @@ async function runScan(options) {
   report({ type: "stage", stage: 1, name: "TCP \u63E1\u624B\u521D\u7B5B", total: candidates.length });
   let done = 0;
   const tcpResults = await pool(candidates, concurrency, async (ip) => {
-    const result = await tcpPing(ip, options.port, tcpTimeoutMs);
+    const result = await withRetry(retries, () => tcpPing(ip, options.port, tcpTimeoutMs));
     done++;
     if (done % 500 === 0 || done === candidates.length) {
       report({
@@ -1346,7 +1399,11 @@ async function runScan(options) {
   report({ type: "stage", stage: 1, name: "TLS \u63E1\u624B\u7B5B\u9009", total: filtered.length });
   let tlsDone = 0;
   const tlsResults = await pool(filtered, tlsConcurrency, async (item) => {
-    const probe = await probeTlsHandshake(item.ip, options.port, options.host, tlsTimeoutMs);
+    const probe = await withRetry(
+      retries,
+      () => probeTlsHandshake(item.ip, options.port, options.host, tlsTimeoutMs),
+      (r) => r.tlsMs > 0
+    );
     tlsDone++;
     if (tlsDone % 200 === 0 || tlsDone === filtered.length) {
       report({
@@ -1374,12 +1431,9 @@ async function runScan(options) {
   const probeResults = await pool(stage1, probeConcurrency, async (item) => {
     const probeFn = strictProbe ? probeWsPing : probeWs101;
     const probePath = strictProbe ? strictProbePath : options.wsPath ?? "/__edge_probe";
-    const result = await probeFn(
-      item.ip,
-      options.port,
-      options.host,
-      probeTimeoutMs,
-      probePath
+    const result = await withRetry(
+      retries,
+      () => probeFn(item.ip, options.port, options.host, probeTimeoutMs, probePath)
     );
     probeDone++;
     if (result.pongVerified) verifiedCount++;
@@ -1532,6 +1586,65 @@ async function postResults(callbackUrl, token, entries, timeoutMs = 15e3) {
     return { ok: false, error: err instanceof Error ? err.message : String(err) };
   }
 }
+async function fetchScannerToken(panelHost, password, timeoutMs = 25e3) {
+  let base = panelHost.trim();
+  if (!base) return { ok: false, error: "\u7F3A\u5C11\u63A7\u5236\u9762\u57DF\u540D\uFF08--panel\uFF09" };
+  if (!/^https?:\/\//i.test(base)) base = "https://" + base;
+  base = base.replace(/\/$/, "");
+  try {
+    const loginRes = await fetch(base + "/api/v1/login", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ password }),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (loginRes.status === 401) {
+      return { ok: false, error: "\u9762\u677F\u5BC6\u7801\u4E0D\u6B63\u786E" };
+    }
+    if (!loginRes.ok) {
+      const text = await loginRes.text().catch(() => "");
+      return { ok: false, error: `\u767B\u5F55\u5931\u8D25 HTTP ${loginRes.status} ${text.slice(0, 120)}` };
+    }
+    const headersWithCookies = loginRes.headers;
+    const raw = headersWithCookies.getSetCookie?.() ?? [];
+    const cookie = raw.map((c) => (c.split(";")[0] ?? "").trim()).filter(Boolean).join("; ");
+    if (!cookie) {
+      const single = loginRes.headers.get("set-cookie");
+      if (!single) {
+        return { ok: false, error: "\u767B\u5F55\u6210\u529F\u4F46\u670D\u52A1\u7AEF\u6CA1\u6709\u4E0B\u53D1\u4F1A\u8BDD Cookie" };
+      }
+      return await takeToken(base, (single.split(";")[0] ?? "").trim(), timeoutMs);
+    }
+    return await takeToken(base, cookie, timeoutMs);
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function takeToken(base, cookie, timeoutMs) {
+  const res = await fetch(base + "/api/v1/scanner-token", {
+    method: "POST",
+    headers: { Cookie: cookie },
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!res.ok) {
+    const text2 = await res.text().catch(() => "");
+    return { ok: false, error: `\u83B7\u53D6\u4EE4\u724C\u5931\u8D25 HTTP ${res.status} ${text2.slice(0, 120)}` };
+  }
+  const text = await res.text();
+  if (text.trimStart().startsWith("<")) {
+    return {
+      ok: false,
+      error: "\u9762\u677F\u8FD4\u56DE\u4E86\u7F51\u9875\u800C\u4E0D\u662F\u63A5\u53E3\u6570\u636E\uFF0C\u8BF7\u786E\u8BA4 --panel \u586B\u7684\u662F\u63A7\u5236\u9762\u57DF\u540D"
+    };
+  }
+  try {
+    const data = JSON.parse(text);
+    if (!data.token) return { ok: false, error: "\u9762\u677F\u6CA1\u6709\u8FD4\u56DE\u4EE4\u724C" };
+    return { ok: true, token: data.token };
+  } catch {
+    return { ok: false, error: "\u4EE4\u724C\u54CD\u5E94\u89E3\u6790\u5931\u8D25\uFF1A" + text.slice(0, 120) };
+  }
+}
 
 // src/server.ts
 import { createServer } from "node:http";
@@ -1804,7 +1917,7 @@ async function handleRequest(req, res) {
 }
 
 // src/version.ts
-var VERSION = "0.4.0";
+var VERSION = "0.6.4";
 var NAME = "cfpilot-scanner";
 
 // src/cli.ts
@@ -1823,8 +1936,11 @@ CFPilot \u672C\u5730\u771F\u8FDE\u63A5\u4F18\u9009\u5668 \u2014\u2014 \u7528\u4F
 scan \u9009\u9879:
   --host <domain>        \u5FC5\u586B\uFF1A\u4F60\u7684 Worker \u81EA\u5B9A\u4E49\u57DF\u540D\uFF08\u4F5C\u4E3A TLS SNI \u4E0E HTTP Host\uFF09
   --port <port>          \u7AEF\u53E3\uFF0C\u9ED8\u8BA4 443
-  --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
+  --panel <domain>       \u63A7\u5236\u9762\u57DF\u540D\uFF08\u5982 cpmanager.pages.dev\uFF09\uFF0C\u56DE\u586B\u5FC5\u586B
+                         \u4E0E --host \u4E0D\u540C\uFF1A--host \u662F\u6570\u636E\u9762\uFF0C\u9762\u677F\u63A5\u53E3\u5728\u63A7\u5236\u9762
+  --panel-password <pw>  \u9762\u677F\u5BC6\u7801\uFF0C\u914D\u5408 --panel \u81EA\u52A8\u83B7\u53D6\u4E34\u65F6\u4EE4\u724C
+  --token <token>        \u56DE\u586B\u4EE4\u724C\uFF08\u4E0D\u60F3\u7ED9\u5BC6\u7801\u65F6\u624B\u52A8\u6307\u5B9A\uFF09
+  --callback <url>       \u81EA\u5B9A\u4E49\u56DE\u586B\u5730\u5740\uFF08\u9ED8\u8BA4\u7531 --panel \u63A8\u5BFC\uFF09
   --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
@@ -1838,6 +1954,8 @@ scan \u9009\u9879:
   --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
+  --retries <n>           \u6BCF\u4E2A\u63A2\u6D4B\u7684\u5C1D\u8BD5\u6B21\u6570\uFF08\u542B\u9996\u6B21\uFF09\uFF0C\u9ED8\u8BA4 2
+                          \u771F\u673A\u5076\u53D1\u5931\u8D25\u7387 3~5%\uFF0C\u91CD\u8BD5\u53D6\u7B2C\u4E00\u6B21\u6210\u529F\u7684\u7ED3\u679C
   --no-verify            \u9636\u6BB5\u4E8C\u53EA\u505A 101 \u63E1\u624B\uFF0C\u8DF3\u8FC7\u54CD\u5E94\u4F53\u6821\u9A8C
                           \uFF08\u9ED8\u8BA4\u6821\u9A8C\uFF1A\u53D1 PING \u5E76\u9A8C\u8BC1\u6570\u636E\u9762\u56DE {"pong":true}\uFF09
   --no-speed             \u8DF3\u8FC7\u6D4B\u901F\uFF0C\u53EA\u6309\u5EF6\u8FDF\u6392\u5E8F
@@ -1845,7 +1963,7 @@ scan \u9009\u9879:
   --concurrency <n>      \u9636\u6BB5\u4E00 TCP \u5E76\u53D1\uFF0C\u9ED8\u8BA4 300
   --tls-concurrency <n>  \u9636\u6BB5\u4E00 TLS \u63E1\u624B\u5E76\u53D1\uFF0C\u9ED8\u8BA4 64
                           TLS \u63E1\u624B\u662F CPU \u5BC6\u96C6\u578B\u64CD\u4F5C\uFF0C\u8FC7\u9AD8\u4F1A\u8BA9\u672C\u673A\u6210\u4E3A\u74F6\u9888
-  --sample <n>           \u5019\u9009 IP \u91C7\u6837\u6570\uFF0C\u9ED8\u8BA4 20000
+  --sample <n>           \u5019\u9009 IP \u91C7\u6837\u6570\uFF0C\u9ED8\u8BA4 6556\uFF08\u4E0E\u754C\u9762\u4E00\u81F4\uFF1B\u4E0D\u5B9C\u8D85\u8FC7 23000\uFF09
                           \u5EFA\u8BAE 6556 \u8D77\uFF1A\u9636\u6BB5\u4E00\u6309 TLS \u63E1\u624B\u8017\u65F6\u7B5B\u9009\uFF0C\u800C\u63E1\u624B\u5FEB\u6162
                           \u4E0E TCP \u5EF6\u8FDF\u51E0\u4E4E\u65E0\u5173\uFF08\u5B9E\u6D4B TCP 9ms \u7684 IP \u53EF\u80FD\u8981 3.5 \u79D2\uFF09\uFF0C
                           \u91C7\u6837\u5C0F\u4E86\u6839\u672C\u78B0\u4E0D\u5230\u63E1\u624B\u5FEB\u7684 IP
@@ -1960,7 +2078,7 @@ async function resolveCandidatesFromArgs(args) {
     return readIpFile(text);
   }
   return resolveCandidates({
-    sample: flagNumber(args, "sample", 2e4),
+    sample: flagNumber(args, "sample", 6556),
     cidr: flagList(args, "cidr"),
     seed: flagNumber(args, "seed", 24301)
   });
@@ -2024,14 +2142,40 @@ async function commandScan(args) {
   }
   const port = flagNumber(args, "port", 443);
   const top = flagNumber(args, "top", 15);
-  const token = flagString(args, "token");
+  let 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 verifyPayload = !flagBool(args, "no-verify");
   const countries = normalizeCountryFilter(flagList(args, "countries"));
-  const callback = noCallback ? "" : flagString(args, "callback", token ? `https://${host}/api/v1/preferred-ips` : "");
+  const panelHost = flagString(args, "panel");
+  const panelPassword = flagString(args, "panel-password");
+  const callbackBase = panelHost || host;
+  let autoTokenUsed = false;
+  if (!token && !noCallback && panelHost && panelPassword) {
+    if (!quiet) {
+      process.stdout.write(`\u6B63\u5728\u5411 ${panelHost} \u7533\u8BF7\u4E34\u65F6\u4EE4\u724C\u2026
+`);
+    }
+    const tk = await fetchScannerToken(panelHost, panelPassword);
+    if (tk.ok && tk.token) {
+      token = tk.token;
+      autoTokenUsed = true;
+      if (!quiet) {
+        process.stdout.write("\u2713 \u5DF2\u83B7\u53D6\u4E34\u65F6\u4EE4\u724C\uFF0810 \u5206\u949F\u6709\u6548\uFF09\n");
+      }
+    } else if (!quiet) {
+      process.stderr.write(`\u26A0 \u81EA\u52A8\u83B7\u53D6\u4EE4\u724C\u5931\u8D25\uFF1A${tk.error}
+`);
+      process.stderr.write("  \u53EF\u6539\u7528 --token <\u4EE4\u724C> \u624B\u52A8\u6307\u5B9A\n");
+    }
+  }
+  const callback = noCallback ? "" : flagString(
+    args,
+    "callback",
+    token || autoTokenUsed ? `https://${callbackBase}/api/v1/preferred-ips` : ""
+  );
   if (!quiet) {
     process.stdout.write(`
 ${NAME} v${VERSION}
@@ -2121,6 +2265,7 @@ ${NAME} v${VERSION}
     skipSpeed,
     verifyPayload,
     concurrency: flagNumber(args, "concurrency", 300),
+    retries: flagNumber(args, "retries", 2),
     tcpTimeoutMs: flagNumber(args, "timeout", 1200),
     tlsConcurrency: flagNumber(args, "tls-concurrency", 64),
     tlsTimeoutMs: flagNumber(args, "tls-timeout", 4e3),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cfpilot-scanner",
-  "version": "0.4.0",
+  "version": "0.6.4",
   "description": "CFPilot 优选器：用你自己的域名做 WebSocket 101 真连接校验，只保留真正可用的 Cloudflare IP；兼容任意 VLESS-WS 项目",
   "license": "MIT",
   "author": "CFPilot Contributors",