cfpilot-scanner 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,89 @@
-# Temporary Holding Version
+# cfpilot-scanner
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**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

package/dist/cli.js

@@ -0,0 +1,1132 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync } from "node:fs";
+
+// src/args.ts
+function parseArgs(argv) {
+  const flags = {};
+  const positionals = [];
+  let command = "";
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      const body = arg.slice(2);
+      const eq = body.indexOf("=");
+      if (eq >= 0) {
+        flags[body.slice(0, eq)] = body.slice(eq + 1);
+        continue;
+      }
+      const next = argv[i + 1];
+      if (next !== void 0 && !next.startsWith("-")) {
+        flags[body] = next;
+        i++;
+      } else {
+        flags[body] = true;
+      }
+      continue;
+    }
+    if (arg.startsWith("-") && arg.length === 2) {
+      const next = argv[i + 1];
+      if (next !== void 0 && !next.startsWith("-")) {
+        flags[arg.slice(1)] = next;
+        i++;
+      } else {
+        flags[arg.slice(1)] = true;
+      }
+      continue;
+    }
+    if (!command) {
+      command = arg;
+    } else {
+      positionals.push(arg);
+    }
+  }
+  return { command, flags, positionals };
+}
+function flagString(args, key, fallback = "") {
+  const value = args.flags[key];
+  if (typeof value === "string") return value;
+  return fallback;
+}
+function flagNumber(args, key, fallback) {
+  const value = args.flags[key];
+  if (typeof value === "string") {
+    const n = Number(value);
+    if (Number.isFinite(n)) return n;
+  }
+  return fallback;
+}
+function flagBool(args, key) {
+  const value = args.flags[key];
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    return !["0", "false", "no", "off"].includes(value.toLowerCase());
+  }
+  return false;
+}
+function flagList(args, key) {
+  const value = args.flags[key];
+  if (typeof value !== "string") return [];
+  return value.split(/[\n,]+/).map((v) => v.trim()).filter(Boolean);
+}
+
+// src/ip-ranges.ts
+var BUILTIN_IPV4_CIDRS = [
+  "173.245.48.0/20",
+  "103.21.244.0/22",
+  "103.22.200.0/22",
+  "103.31.4.0/22",
+  "141.101.64.0/18",
+  "108.162.192.0/18",
+  "190.93.240.0/20",
+  "188.114.96.0/20",
+  "197.234.240.0/22",
+  "198.41.128.0/17",
+  "162.158.0.0/15",
+  "104.16.0.0/13",
+  "104.24.0.0/14",
+  "172.64.0.0/13",
+  "131.0.72.0/22"
+];
+var BUILTIN_IPV6_CIDRS = [
+  "2400:cb00::/32",
+  "2606:4700::/32",
+  "2803:f800::/32",
+  "2405:b500::/32",
+  "2405:8100::/32",
+  "2a06:98c0::/29",
+  "2c0f:f248::/32"
+];
+async function fetchCloudflareCidrs(timeoutMs = 8e3) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const [v4, v6] = await Promise.all([
+      fetch("https://www.cloudflare.com/ips-v4", { signal: controller.signal }),
+      fetch("https://www.cloudflare.com/ips-v6", { signal: controller.signal })
+    ]);
+    const parse = (text) => text.split("\n").map((l) => l.trim()).filter((l) => l.includes("/"));
+    return {
+      ipv4: v4.ok ? parse(await v4.text()) : BUILTIN_IPV4_CIDRS,
+      ipv6: v6.ok ? parse(await v6.text()) : BUILTIN_IPV6_CIDRS
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function makeRandom(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a |= 0;
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function parseCidr(cidr) {
+  const [addr, prefixText] = cidr.trim().split("/");
+  if (!addr) return null;
+  const prefix = Number(prefixText);
+  if (!Number.isInteger(prefix)) return null;
+  if (addr.includes(":")) {
+    if (prefix < 0 || prefix > 128) return null;
+    const base = ipv6ToBigInt(addr);
+    if (base === null) return null;
+    const hostBits2 = 128 - prefix;
+    const size2 = 1n << BigInt(hostBits2);
+    const mask2 = hostBits2 === 0 ? 0n : (1n << BigInt(hostBits2)) - 1n;
+    return { family: 6, base: base & ~mask2, prefix, size: size2 };
+  }
+  if (prefix < 0 || prefix > 32) return null;
+  const value = ipv4ToBigInt(addr);
+  if (value === null) return null;
+  const hostBits = 32 - prefix;
+  const size = 1n << BigInt(hostBits);
+  const mask = hostBits === 0 ? 0n : (1n << BigInt(hostBits)) - 1n;
+  return { family: 4, base: value & ~mask, prefix, size };
+}
+function ipv4ToBigInt(addr) {
+  const parts = addr.split(".");
+  if (parts.length !== 4) return null;
+  let value = 0n;
+  for (const part of parts) {
+    if (!/^\d{1,3}$/.test(part)) return null;
+    const n = Number(part);
+    if (n > 255) return null;
+    value = value << 8n | BigInt(n);
+  }
+  return value;
+}
+function ipv6ToBigInt(addr) {
+  try {
+    const parts = addr.split("::");
+    if (parts.length > 2) return null;
+    const head = parts[0] ? parts[0].split(":") : [];
+    const tail = parts.length === 2 && parts[1] ? parts[1].split(":") : [];
+    const groups = [...head, ...Array(8 - head.length - tail.length).fill("0"), ...tail];
+    if (groups.length !== 8) return null;
+    let value = 0n;
+    for (const group of groups) {
+      if (!/^[0-9a-fA-F]{1,4}$/.test(group)) return null;
+      value = value << 16n | BigInt(parseInt(group, 16));
+    }
+    return value;
+  } catch {
+    return null;
+  }
+}
+function bigIntToIpv4(value) {
+  return [24n, 16n, 8n, 0n].map((shift) => (value >> shift & 0xffn).toString()).join(".");
+}
+function bigIntToIpv6(value) {
+  const groups = [];
+  for (let i = 7; i >= 0; i--) {
+    groups.push((value >> BigInt(i * 16) & 0xffffn).toString(16));
+  }
+  let bestStart = -1;
+  let bestLen = 0;
+  let start = -1;
+  let len = 0;
+  for (let i = 0; i < groups.length; i++) {
+    if (groups[i] === "0") {
+      if (start < 0) start = i;
+      len++;
+      if (len > bestLen) {
+        bestLen = len;
+        bestStart = start;
+      }
+    } else {
+      start = -1;
+      len = 0;
+    }
+  }
+  if (bestLen < 2) return groups.join(":");
+  const head = groups.slice(0, bestStart).join(":");
+  const tail = groups.slice(bestStart + bestLen).join(":");
+  return `${head}::${tail}`;
+}
+function expandCidrs(cidrs, options = {}) {
+  const sample = options.sample ?? 2e4;
+  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) {
+      for (let i = 0n; i < cidr.size; i++) {
+        const value = cidr.base + i;
+        out.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 out;
+}
+function readIpFile(text) {
+  const out = [];
+  for (const raw of text.split(/\r?\n/)) {
+    let line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    if (line.includes(",")) line = line.split(",")[0].trim();
+    const hash = line.indexOf("#");
+    if (hash >= 0) line = line.slice(0, hash).trim();
+    if (!line) continue;
+    const bracket = /^\[([^\]]+)\](?::\d+)?$/.exec(line);
+    if (bracket) {
+      out.push(bracket[1]);
+      continue;
+    }
+    if (line.includes(":") && line.split(":").length > 2) {
+      out.push(line);
+      continue;
+    }
+    if (line.includes(":")) {
+      const [host] = line.split(":");
+      if (host) out.push(host);
+      continue;
+    }
+    out.push(line);
+  }
+  return out;
+}
+
+// src/candidates.ts
+var DEFAULT_CANDIDATE_SAMPLE = 2e4;
+var DEFAULT_CANDIDATE_SEED = 24301;
+var DEFAULT_BRIDGE_SAMPLE = 300;
+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/scan.ts
+import * as net from "node:net";
+
+// src/true-probe.ts
+import * as tls 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) {
+  return new Promise((resolve) => {
+    const started = Date.now();
+    const key = crypto.randomBytes(16).toString("base64");
+    let settled = false;
+    let received = "";
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        socket.destroy();
+      } catch {
+      }
+      resolve({ ...result, latencyMs: Date.now() - started });
+    };
+    const request = [
+      `GET /__edge_probe HTTP/1.1`,
+      `Host: ${host}`,
+      `Upgrade: websocket`,
+      `Connection: Upgrade`,
+      `Sec-WebSocket-Key: ${key}`,
+      `Sec-WebSocket-Version: 13`,
+      `User-Agent: ${USER_AGENT}`,
+      "",
+      ""
+    ].join("\r\n");
+    const socket = tls.connect(
+      {
+        host: ip,
+        port,
+        servername: host,
+        rejectUnauthorized: false,
+        ALPNProtocols: ["http/1.1"]
+      },
+      () => {
+        socket.write(request);
+      }
+    );
+    const timer = setTimeout(() => {
+      finish({ ok: false, colo: "", status: 0, error: "\u63E1\u624B\u8D85\u65F6" });
+    }, timeoutMs);
+    socket.setTimeout(timeoutMs, () => {
+      finish({ ok: false, colo: "", status: 0, error: "\u8FDE\u63A5\u8D85\u65F6" });
+    });
+    socket.on("error", (err) => {
+      finish({ ok: false, colo: "", status: 0, error: err.message });
+    });
+    socket.on("data", (chunk) => {
+      received += chunk.toString("utf8");
+      const lineEnd = received.indexOf("\r\n");
+      const statusLine = lineEnd >= 0 ? received.slice(0, lineEnd) : received;
+      const statusMatch = /^HTTP\/1\.[01]\s+(\d{3})/.exec(statusLine);
+      if (statusMatch) {
+        const status = Number(statusMatch[1]);
+        if (status === 101) {
+          finish({ ok: true, colo: extractColo(received), status });
+        } else {
+          finish({ ok: false, colo: extractColo(received), status, error: `HTTP ${status}` });
+        }
+        return;
+      }
+      if (received.length > 4096) {
+        finish({ ok: false, colo: "", status: 0, error: "\u54CD\u5E94\u5F02\u5E38" });
+      }
+    });
+  });
+}
+function measureDownload(ip, port, host, bytes, timeoutMs = 12e3) {
+  return new Promise((resolve) => {
+    const started = Date.now();
+    let headerEnd = -1;
+    let received = 0;
+    let settled = false;
+    let buffer = "";
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        socket.destroy();
+      } catch {
+      }
+      resolve({ ...result, ms: Date.now() - started });
+    };
+    const request = [
+      `GET /__edge_probe?bytes=${bytes} HTTP/1.1`,
+      `Host: ${host}`,
+      `User-Agent: ${USER_AGENT}`,
+      `Accept: */*`,
+      "",
+      ""
+    ].join("\r\n");
+    const socket = tls.connect(
+      {
+        host: ip,
+        port,
+        servername: host,
+        rejectUnauthorized: false,
+        ALPNProtocols: ["http/1.1"]
+      },
+      () => {
+        socket.write(request);
+      }
+    );
+    const timer = setTimeout(() => {
+      const seconds = Math.max(1e-3, (Date.now() - started) / 1e3);
+      finish({
+        ok: received > 0,
+        bytes: received,
+        speedMBps: received / 1024 / 1024 / seconds,
+        error: received > 0 ? void 0 : "\u6D4B\u901F\u8D85\u65F6"
+      });
+    }, timeoutMs);
+    socket.setTimeout(timeoutMs, () => {
+      const seconds = Math.max(1e-3, (Date.now() - started) / 1e3);
+      finish({
+        ok: received > 0,
+        bytes: received,
+        speedMBps: received / 1024 / 1024 / seconds,
+        error: received > 0 ? void 0 : "\u6D4B\u901F\u8D85\u65F6"
+      });
+    });
+    socket.on("error", (err) => {
+      finish({ ok: false, bytes: received, speedMBps: 0, error: err.message });
+    });
+    socket.on("data", (chunk) => {
+      if (headerEnd < 0) {
+        buffer += chunk.toString("latin1");
+        const idx = buffer.indexOf("\r\n\r\n");
+        if (idx < 0) {
+          if (buffer.length > 8192) finish({ ok: false, bytes: 0, speedMBps: 0, error: "\u54CD\u5E94\u5934\u5F02\u5E38" });
+          return;
+        }
+        headerEnd = idx + 4;
+        const body = Buffer.from(buffer, "latin1").subarray(headerEnd);
+        received += body.byteLength;
+        headerEnd = 0;
+        return;
+      }
+      received += chunk.byteLength;
+    });
+  });
+}
+
+// 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 done = (ok) => {
+      if (settled) return;
+      settled = true;
+      try {
+        socket.destroy();
+      } catch {
+      }
+      resolve({ ip, ok, latency: Date.now() - started });
+    };
+    socket.setTimeout(timeoutMs, () => done(false));
+    socket.once("connect", () => done(true));
+    socket.once("error", () => done(false));
+    socket.connect(port, ip);
+  });
+}
+async function pool(items, concurrency, worker) {
+  const out = new Array(items.length);
+  let cursor = 0;
+  const runners = Array.from({ length: Math.max(1, Math.min(concurrency, items.length)) }, async () => {
+    for (; ; ) {
+      const index = cursor++;
+      if (index >= items.length) return;
+      out[index] = await worker(items[index], index);
+    }
+  });
+  await Promise.all(runners);
+  return out;
+}
+async function runScan(options) {
+  const started = Date.now();
+  const concurrency = options.concurrency ?? 300;
+  const tcpTimeoutMs = options.tcpTimeoutMs ?? 1200;
+  const maxLatencyMs = options.maxLatencyMs ?? 0;
+  const probeLimit = options.probeLimit ?? 120;
+  const probeConcurrency = options.probeConcurrency ?? 24;
+  const probeTimeoutMs = options.probeTimeoutMs ?? 3e3;
+  const speedLimit = options.speedLimit ?? 30;
+  const speedConcurrency = options.speedConcurrency ?? 4;
+  const speedTimeoutMs = options.speedTimeoutMs ?? 12e3;
+  const speedBytes = options.speedBytes ?? 5 * 1024 * 1024;
+  const top = options.top ?? 15;
+  const candidates = options.candidates;
+  const report = options.onProgress ?? (() => {
+  });
+  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);
+    done++;
+    if (done % 500 === 0 || done === candidates.length) {
+      report({
+        type: "progress",
+        stage: 1,
+        done,
+        total: candidates.length,
+        message: `TCP \u521D\u7B5B ${done}/${candidates.length}`
+      });
+    }
+    return result;
+  });
+  const tcpOk = tcpResults.filter((r) => r.ok);
+  const filtered = maxLatencyMs > 0 ? tcpOk.filter((r) => r.latency <= maxLatencyMs) : tcpOk;
+  const stage1 = filtered.sort((a, b) => a.latency - b.latency).slice(0, probeLimit);
+  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);
+    probeDone++;
+    report({
+      type: "progress",
+      stage: 2,
+      done: probeDone,
+      total: stage1.length,
+      message: `101 \u6821\u9A8C ${probeDone}/${stage1.length}${result.ok ? ` \u2713 ${result.colo}` : ""}`
+    });
+    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`
+    });
+    return { ...item, download: result };
+  });
+  const entries = speedResults.filter((r) => 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);
+  for (const entry of entries) {
+    report({ type: "result", entry });
+  }
+  const summary = {
+    entries,
+    stats: {
+      candidates: candidates.length,
+      tcpOk: tcpOk.length,
+      wsOk: wsOk.length,
+      speedOk: entries.length,
+      elapsedMs: Date.now() - started
+    }
+  };
+  report({ type: "done", count: entries.length });
+  return summary;
+}
+function formatEntries(entries) {
+  return entries.map((e) => `${e.ip}:${e.port}#${e.colo}_${e.latency}_${e.speed}`);
+}
+
+// src/callback.ts
+async function postResults(callbackUrl, token, entries, timeoutMs = 15e3) {
+  try {
+    const response = await fetch(callbackUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+        "User-Agent": "CFPilot-Scanner/1.0"
+      },
+      body: JSON.stringify({ ips: entries }),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      return { ok: false, status: response.status, error: `\u56DE\u4F20\u5931\u8D25 HTTP ${response.status} ${text}`.trim() };
+    }
+    return { ok: true, status: response.status };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+
+// src/server.ts
+import { createServer } from "node:http";
+var BRIDGE_VERSION = "0.1.0";
+var DEFAULT_BRIDGE_PORT = 19527;
+function normalizeSample(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    return Math.min(Math.floor(value), DEFAULT_CANDIDATE_SAMPLE);
+  }
+  return DEFAULT_BRIDGE_SAMPLE;
+}
+function normalizeSeed(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return Math.trunc(value);
+  return void 0;
+}
+function normalizeFamily(value) {
+  return value === "v4" || value === "v6" || value === "both" ? value : void 0;
+}
+async function resolveScanCandidates(body) {
+  const manual = normalizeCandidateList(body.manual);
+  if (manual.length > 0) return { candidates: manual, source: "manual" };
+  const requested = normalizeCandidateList(body.candidates);
+  if (requested.length > 0) return { candidates: requested, source: "request" };
+  const candidates = await resolveCandidates({
+    sample: normalizeSample(body.sample),
+    cidr: body.cidr,
+    seed: normalizeSeed(body.seed),
+    family: normalizeFamily(body.family)
+  });
+  return { candidates, source: "generated" };
+}
+function describePlan(plan) {
+  if (plan.source === "manual") return `\u4F7F\u7528\u9762\u677F\u624B\u52A8\u6307\u5B9A\u7684 ${plan.candidates.length} \u4E2A\u5019\u9009 IP`;
+  if (plan.source === "request") return `\u4F7F\u7528\u8BF7\u6C42\u643A\u5E26\u7684 ${plan.candidates.length} \u4E2A\u5019\u9009 IP`;
+  return `\u5DF2\u81EA\u52A8\u751F\u6210 ${plan.candidates.length} \u4E2A\u5019\u9009 IP`;
+}
+var jobs = /* @__PURE__ */ new Map();
+var jobCounter = 0;
+function corsHeaders() {
+  return {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type, Authorization",
+    "Access-Control-Max-Age": "86400"
+  };
+}
+function sendJson(res, status, data) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Content-Length": Buffer.byteLength(body),
+    ...corsHeaders()
+  });
+  res.end(body);
+}
+async function readBody(req) {
+  const chunks = [];
+  for await (const chunk of req) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+function parseStartScanRequest(text) {
+  try {
+    const raw = JSON.parse(text || "{}");
+    if (typeof raw !== "object" || raw === null) return null;
+    return raw;
+  } catch {
+    return null;
+  }
+}
+function eventToSse(event) {
+  switch (event.type) {
+    case "stage":
+      return `event: stage
+data: ${JSON.stringify({ stage: event.stage, name: event.name, total: event.total })}
+
+`;
+    case "progress":
+      return `event: progress
+data: ${JSON.stringify({
+        stage: event.stage,
+        done: event.done,
+        total: event.total,
+        percent: event.total > 0 ? Math.round(event.done / event.total * 100) : 0,
+        message: event.message
+      })}
+
+`;
+    case "result":
+      return `event: result
+data: ${JSON.stringify({ entry: event.entry })}
+
+`;
+    case "done":
+      return `event: done
+data: ${JSON.stringify({ count: event.count })}
+
+`;
+    case "error":
+    default:
+      return `event: error
+data: ${JSON.stringify({ message: event.message })}
+
+`;
+  }
+}
+function broadcast(job, event) {
+  job.events.push(event);
+  const payload = eventToSse(event);
+  for (const subscriber of job.subscribers) {
+    try {
+      subscriber.write(payload);
+    } catch {
+      job.subscribers.delete(subscriber);
+    }
+  }
+}
+function startBridge(options = {}) {
+  const host = options.host ?? "127.0.0.1";
+  const port = options.port ?? DEFAULT_BRIDGE_PORT;
+  const server = createServer((req, res) => {
+    void handleRequest(req, res).catch((err) => {
+      sendJson(res, 500, { ok: false, error: err instanceof Error ? err.message : String(err) });
+    });
+  });
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, host, () => {
+      const address = server.address();
+      const boundPort = typeof address === "object" && address !== null ? address.port : port;
+      resolve({
+        server,
+        port: boundPort,
+        close: () => new Promise((done) => {
+          for (const job of jobs.values()) {
+            for (const subscriber of job.subscribers) subscriber.end();
+            job.subscribers.clear();
+          }
+          server.close(() => done());
+        })
+      });
+    });
+  });
+}
+async function handleRequest(req, res) {
+  const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "127.0.0.1"}`);
+  if (req.method === "OPTIONS") {
+    res.writeHead(204, corsHeaders());
+    res.end();
+    return;
+  }
+  if (url.pathname === "/status") {
+    const active = [...jobs.values()].filter((j) => !j.finished);
+    const last = [...jobs.values()].sort((a, b) => b.startedAt - a.startedAt)[0];
+    sendJson(res, 200, {
+      ok: true,
+      version: BRIDGE_VERSION,
+      busy: active.length > 0,
+      lastJobId: last?.id ?? null,
+      lastCount: last?.result.length ?? 0
+    });
+    return;
+  }
+  if (url.pathname === "/start-scan" && req.method === "POST") {
+    const body = parseStartScanRequest(await readBody(req));
+    if (!body) {
+      sendJson(res, 400, { ok: false, error: "\u8BF7\u6C42\u4F53\u89E3\u6790\u5931\u8D25\uFF08\u9700\u8981 JSON \u5BF9\u8C61\uFF09" });
+      return;
+    }
+    if (typeof body.host !== "string" || body.host.trim() === "") {
+      sendJson(res, 400, { ok: false, error: "\u7F3A\u5C11 host \u53C2\u6570" });
+      return;
+    }
+    const job = {
+      id: `job-${Date.now()}-${++jobCounter}`,
+      startedAt: Date.now(),
+      events: [],
+      subscribers: /* @__PURE__ */ new Set(),
+      result: [],
+      finished: false
+    };
+    jobs.set(job.id, job);
+    void (async () => {
+      try {
+        const plan = await resolveScanCandidates(body);
+        if (plan.candidates.length === 0) {
+          broadcast(job, {
+            type: "error",
+            message: "\u6CA1\u6709\u53EF\u7528\u7684\u5019\u9009 IP\uFF1A\u8BF7\u68C0\u67E5 candidates / manual / cidr \u53C2\u6570"
+          });
+          job.finished = true;
+          return;
+        }
+        broadcast(job, {
+          type: "progress",
+          stage: 0,
+          done: 0,
+          total: plan.candidates.length,
+          message: describePlan(plan)
+        });
+        const summary = await runScan({
+          host: body.host.trim(),
+          port: body.port ?? 443,
+          candidates: plan.candidates,
+          top: body.top ?? 15,
+          onProgress: (event) => broadcast(job, event)
+        });
+        job.result = summary.entries;
+        if (body.callback && body.token) {
+          const result = await postResults(body.callback, body.token, formatEntries(summary.entries));
+          broadcast(
+            job,
+            result.ok ? { type: "done", count: summary.entries.length } : { type: "error", message: `\u56DE\u4F20\u5931\u8D25\uFF1A${result.error ?? "\u672A\u77E5\u9519\u8BEF"}` }
+          );
+        } else {
+          broadcast(job, { type: "done", count: summary.entries.length });
+        }
+      } catch (err) {
+        broadcast(job, { type: "error", message: err instanceof Error ? err.message : String(err) });
+      } finally {
+        job.finished = true;
+        for (const subscriber of job.subscribers) {
+          try {
+            subscriber.end();
+          } catch {
+          }
+        }
+        job.subscribers.clear();
+      }
+    })();
+    sendJson(res, 200, { ok: true, jobId: job.id });
+    return;
+  }
+  if (url.pathname === "/events") {
+    const jobId = url.searchParams.get("jobId") ?? "";
+    const job = jobs.get(jobId) ?? [...jobs.values()].sort((a, b) => b.startedAt - a.startedAt)[0];
+    if (!job) {
+      sendJson(res, 404, { ok: false, error: "\u6CA1\u6709\u6B63\u5728\u8FD0\u884C\u7684\u4EFB\u52A1" });
+      return;
+    }
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream; charset=utf-8",
+      "Cache-Control": "no-store",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no",
+      ...corsHeaders()
+    });
+    for (const event of job.events) res.write(eventToSse(event));
+    if (job.finished) {
+      res.end();
+      return;
+    }
+    job.subscribers.add(res);
+    req.on("close", () => {
+      job.subscribers.delete(res);
+    });
+    return;
+  }
+  if (url.pathname === "/results") {
+    const job = [...jobs.values()].sort((a, b) => b.startedAt - a.startedAt)[0];
+    sendJson(res, 200, {
+      ok: true,
+      entries: job?.result ?? [],
+      lines: formatEntries(job?.result ?? [])
+    });
+    return;
+  }
+  sendJson(res, 404, { ok: false, error: "\u63A5\u53E3\u4E0D\u5B58\u5728" });
+}
+
+// src/version.ts
+var VERSION = "0.1.0";
+var NAME = "cfpilot-scanner";
+
+// src/cli.ts
+var HELP = `
+${NAME} v${VERSION}
+CFPilot \u672C\u5730\u771F\u8FDE\u63A5\u4F18\u9009\u5668 \u2014\u2014 \u7528\u4F60\u81EA\u5DF1\u7684 Worker \u57DF\u540D\u505A SNI/Host\uFF0C
+\u5B8C\u6210 WebSocket 101 \u771F\u8FDE\u63A5\u6821\u9A8C\uFF0C\u53EA\u4FDD\u7559\u771F\u6B63\u53EF\u7528\u7684 IP\u3002
+
+\u7528\u6CD5:
+  ${NAME} scan [\u9009\u9879]        \u6267\u884C\u4E09\u9636\u4F18\u9009\u626B\u63CF\uFF08\u9ED8\u8BA4\u547D\u4EE4\uFF09
+  ${NAME} serve [\u9009\u9879]       \u542F\u52A8\u672C\u5730\u6865\u63A5\u670D\u52A1\uFF08\u4F9B\u9762\u677F\u4E00\u952E\u5524\u9192\uFF09
+  ${NAME} ips [\u9009\u9879]         \u6253\u5370 Cloudflare \u5B98\u65B9\u7F51\u6BB5
+  ${NAME} --help             \u663E\u793A\u5E2E\u52A9
+  ${NAME} --version          \u663E\u793A\u7248\u672C
+
+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
+  --no-callback          \u53EA\u6253\u5370\u7ED3\u679C\uFF0C\u4E0D\u56DE\u586B
+  --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
+  --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
+  --probe-limit <n>      \u8FDB\u5165 101 \u6821\u9A8C\u7684\u5019\u9009\u6570\uFF0C\u9ED8\u8BA4 120
+  --speed-limit <n>      \u8FDB\u5165\u6D4B\u901F\u7684\u5019\u9009\u6570\uFF0C\u9ED8\u8BA4 30
+  --speed-bytes <n>      \u6D4B\u901F\u5B57\u8282\u6570\uFF0C\u9ED8\u8BA4 5242880
+  --timeout <ms>         \u9636\u6BB5\u4E00\u8D85\u65F6\uFF0C\u9ED8\u8BA4 1200
+  --seed <n>             \u91C7\u6837\u968F\u673A\u79CD\u5B50\uFF0C\u9ED8\u8BA4 24301
+  --json                 \u4EE5 JSON \u8F93\u51FA\u7ED3\u679C
+  --quiet                \u4EC5\u8F93\u51FA\u7ED3\u679C
+
+serve \u9009\u9879:
+  --port <port>          \u76D1\u542C\u7AEF\u53E3\uFF0C\u9ED8\u8BA4 ${DEFAULT_BRIDGE_PORT}
+  --host <addr>          \u76D1\u542C\u5730\u5740\uFF0C\u9ED8\u8BA4 127.0.0.1
+
+\u793A\u4F8B:
+  ${NAME} scan --host cfpilot.example.com --token abc123
+  ${NAME} serve
+`;
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const command = args.command && !args.command.startsWith("-") ? args.command : "";
+  if (flagBool(args, "h") || flagBool(args, "help") || command === "help") {
+    process.stdout.write(HELP);
+    return;
+  }
+  if (flagBool(args, "v") || flagBool(args, "version") || command === "version") {
+    process.stdout.write(`${VERSION}
+`);
+    return;
+  }
+  switch (command) {
+    case "serve":
+      await commandServe(args);
+      return;
+    case "ips":
+      commandIps(args);
+      return;
+    case "scan":
+      await commandScan(args);
+      return;
+    default:
+      await commandScan(args);
+  }
+}
+function commandIps(args) {
+  const includeIpv6 = !flagBool(args, "no-ipv6");
+  const cidrs = [...BUILTIN_IPV4_CIDRS, ...includeIpv6 ? BUILTIN_IPV6_CIDRS : []];
+  process.stdout.write(`${cidrs.join("\n")}
+`);
+}
+async function commandServe(args) {
+  const port = flagNumber(args, "port", DEFAULT_BRIDGE_PORT);
+  const host = flagString(args, "host", "127.0.0.1");
+  const handle = await startBridge({ port, host });
+  process.stdout.write(
+    [
+      "",
+      `  ${NAME} \u672C\u5730\u6865\u63A5\u670D\u52A1\u5DF2\u542F\u52A8`,
+      `  \u76D1\u542C\u5730\u5740\uFF1Ahttp://${host}:${handle.port}`,
+      `  \u7248\u672C\uFF1Av${BRIDGE_VERSION}`,
+      "  \u73B0\u5728\u53EF\u4EE5\u5728 CFPilot \u9762\u677F\u70B9\u51FB\u300C\u4E00\u952E\u672C\u5730\u771F\u8FDE\u63A5\u4F18\u9009\u300D\u3002",
+      "  \u6309 Ctrl+C \u9000\u51FA\u3002",
+      ""
+    ].join("\n")
+  );
+  const shutdown = () => {
+    void handle.close().then(() => process.exit(0));
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+async function resolveCandidatesFromArgs(args) {
+  const ipFile = flagString(args, "ip-file");
+  if (ipFile) {
+    const text = readFileSync(ipFile, "utf8");
+    return readIpFile(text);
+  }
+  return resolveCandidates({
+    sample: flagNumber(args, "sample", 2e4),
+    cidr: flagList(args, "cidr"),
+    seed: flagNumber(args, "seed", 24301)
+  });
+}
+function printProgress(event, quiet) {
+  if (quiet) return;
+  switch (event.type) {
+    case "stage":
+      process.stdout.write(`
+\u25B6 \u9636\u6BB5 ${event.stage}\uFF1A${event.name}\uFF08\u5171 ${event.total} \u4E2A\u5019\u9009\uFF09
+`);
+      break;
+    case "progress":
+      if (event.message) process.stdout.write(`\r  ${event.message}`.padEnd(78));
+      break;
+    case "done":
+      process.stdout.write(`
+\u2713 \u4F18\u9009\u5B8C\u6210\uFF0C\u5171 ${event.count} \u6761
+`);
+      break;
+    case "error":
+      process.stdout.write(`
+\u2717 ${event.message}
+`);
+      break;
+    default:
+      break;
+  }
+}
+function printTable(entries) {
+  if (entries.length === 0) {
+    process.stdout.write("\n\u6CA1\u6709\u901A\u8FC7\u5168\u90E8\u6821\u9A8C\u7684\u8282\u70B9\u3002\n");
+    return;
+  }
+  process.stdout.write("\n\u6392\u540D  \u5730\u5740                     \u673A\u623F   \u5EF6\u8FDF(ms)  \u4E0B\u884C(MB/s)\n");
+  process.stdout.write("\u2500".repeat(58) + "\n");
+  entries.forEach((entry, index) => {
+    const rank = String(index + 1).padStart(2, " ");
+    const address = `${entry.ip}:${entry.port}`.padEnd(24, " ");
+    const colo = (entry.colo || "UNK").padEnd(6, " ");
+    const latency = String(entry.latency).padStart(7, " ");
+    const speed = entry.speed.toFixed(1).padStart(9, " ");
+    process.stdout.write(`${rank}   ${address} ${colo} ${latency}  ${speed}
+`);
+  });
+}
+async function commandScan(args) {
+  const host = flagString(args, "host");
+  const quiet = flagBool(args, "quiet");
+  const asJson = flagBool(args, "json");
+  if (!host) {
+    process.stderr.write("\u7F3A\u5C11 --host \u53C2\u6570\uFF08\u4F60\u7684 Worker \u81EA\u5B9A\u4E49\u57DF\u540D\uFF09\n");
+    process.stderr.write('\u63D0\u793A\uFF1Anpx -y cfpilot-scanner@latest --host "\u4F60\u7684\u57DF\u540D" --token "\u4EE4\u724C"\n');
+    process.exit(1);
+  }
+  const port = flagNumber(args, "port", 443);
+  const top = flagNumber(args, "top", 15);
+  const token = flagString(args, "token");
+  const noCallback = flagBool(args, "no-callback");
+  const callback = noCallback ? "" : flagString(args, "callback", token ? `https://${host}/api/v1/preferred-ips` : "");
+  if (!quiet) {
+    process.stdout.write(`
+${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");
+  }
+  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");
+    process.exit(1);
+  }
+  if (!quiet) process.stdout.write(`\u5019\u9009 IP\uFF1A${candidates.length} \u4E2A
+`);
+  const summary = await runScan({
+    host,
+    port,
+    candidates,
+    concurrency: flagNumber(args, "concurrency", 300),
+    tcpTimeoutMs: flagNumber(args, "timeout", 1200),
+    maxLatencyMs: flagNumber(args, "max-latency", 0),
+    probeLimit: flagNumber(args, "probe-limit", 120),
+    probeTimeoutMs: flagNumber(args, "probe-timeout", 3e3),
+    speedLimit: flagNumber(args, "speed-limit", 30),
+    speedTimeoutMs: flagNumber(args, "speed-timeout", 12e3),
+    speedBytes: flagNumber(args, "speed-bytes", 5 * 1024 * 1024),
+    top,
+    onProgress: (event) => printProgress(event, quiet)
+  });
+  if (asJson) {
+    process.stdout.write(
+      `${JSON.stringify({ entries: summary.entries, stats: summary.stats }, null, 2)}
+`
+    );
+  } else {
+    printTable(summary.entries);
+  }
+  if (callback && token) {
+    const result = await postResults(callback, token, formatEntries(summary.entries));
+    if (result.ok) {
+      process.stdout.write(`
+\u2713 \u5DF2\u56DE\u586B ${summary.entries.length} \u6761\u5230\u9762\u677F
+`);
+    } else {
+      process.stderr.write(`
+\u2717 \u56DE\u586B\u5931\u8D25\uFF1A${result.error}
+`);
+      process.exitCode = 1;
+    }
+  } else if (!quiet) {
+    process.stdout.write("\n\uFF08\u672A\u63D0\u4F9B --token\uFF0C\u8DF3\u8FC7\u56DE\u586B\uFF09\n");
+  }
+}
+main().catch((err) => {
+  process.stderr.write(`\u6267\u884C\u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,41 @@
 {
   "name": "cfpilot-scanner",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "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"
+  }
+}