cfpilot-scanner 0.1.0 → 0.2.0

package/README.md

@@ -1,89 +1,119 @@
-# 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
+```
+
+## 对接任意 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
+```
+
+- 阶段二会对 `<path>` 发起真实的 **TLS + WebSocket 101** 握手，只有 101 才算可用
+- 如果目标没有测速端点，会自动跳过测速、只按延迟排序（不会再干等 12 秒）
+- 想测速可加 `--probe-path <路径>` 与 `--no-speed` 控制行为
+
+## 输出：直接可复制的列表
+
+扫描结束后会额外打印一段，**一行一个，直接粘进同类项目的「自定义 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

@@ -337,7 +337,7 @@ 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 +354,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`,
@@ -405,7 +405,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,7 +423,7 @@ 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: */*`,
@@ -463,6 +463,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,10 +480,13 @@ 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);
   });
 }
 
@@ -554,7 +562,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",
@@ -567,33 +575,40 @@ async function runScan(options) {
   });
   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`
+  let speedResults;
+  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 {
+    report({ type: "stage", stage: 3, name: "\u771F\u5B9E\u4E0B\u884C\u901F\u5EA6\u6D4B\u8BD5", 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, download: result };
     });
-    return { ...item, download: result };
-  });
-  const entries = speedResults.filter((r) => r.download.ok && r.download.speedMBps > 0).map((r) => ({
+  }
+  const entries = speedResults.filter((r) => options.skipSpeed ? true : Boolean(r.download && r.download.ok && r.download.speedMBps > 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.download ? Number(r.download.speedMBps.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 });
   }
@@ -610,6 +625,9 @@ async function runScan(options) {
   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 +657,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) {
@@ -906,7 +924,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,6 +946,10 @@ 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>    \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
   --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
@@ -1057,6 +1079,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 +1097,9 @@ 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 noSpeed = flagBool(args, "no-speed");
   const callback = noCallback ? "" : flagString(args, "callback", token ? `https://${host}/api/v1/preferred-ips` : "");
   if (!quiet) {
     process.stdout.write(`
@@ -1086,10 +1116,31 @@ ${NAME} v${VERSION}
   }
   if (!quiet) process.stdout.write(`\u5019\u9009 IP\uFF1A${candidates.length} \u4E2A
 `);
+  let skipSpeed = noSpeed;
+  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;
+        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");
+        }
+      }
+    } catch {
+      skipSpeed = true;
+    }
+  }
   const summary = await runScan({
     host,
     port,
     candidates,
+    wsPath,
+    probePath,
+    skipSpeed,
     concurrency: flagNumber(args, "concurrency", 300),
     tcpTimeoutMs: flagNumber(args, "timeout", 1200),
     maxLatencyMs: flagNumber(args, "max-latency", 0),
@@ -1108,6 +1159,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,41 +1,41 @@
-{
-  "name": "cfpilot-scanner",
-  "version": "0.1.0",
-  "description": "CFPilot 本地真连接优选器：用你自己的 Worker 域名做 SNI/Host 完成 WebSocket 101 真连接校验，彻底消灭 -1 节点",
-  "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.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"
+  }
+}