cfpilot 0.43.0 → 0.60.0-beta.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/cli.js CHANGED
@@ -87,7 +87,7 @@ var VERSION, NAME;
87
87
  var init_version = __esm({
88
88
  "src/shared/version.ts"() {
89
89
  "use strict";
90
- VERSION = "0.43.0";
90
+ VERSION = "0.60.0-beta.1";
91
91
  NAME = "cfpilot";
92
92
  }
93
93
  });
@@ -217,7 +217,7 @@ async function ask(question, options = {}) {
217
217
  }
218
218
  const suffix = fallback ? c.gray(` [${fallback}]`) : "";
219
219
  stdout.write(`${c.cyan("?")} ${question}${suffix}${c.gray(": ")}`);
220
- return await new Promise((resolve4) => {
220
+ return await new Promise((resolve5) => {
221
221
  let buf = "";
222
222
  const wasRaw = stdin.isRaw;
223
223
  const finish = (value) => {
@@ -225,7 +225,7 @@ async function ask(question, options = {}) {
225
225
  stdin.setRawMode(wasRaw ?? false);
226
226
  stdin.pause();
227
227
  stdout.write("\n");
228
- resolve4(value);
228
+ resolve5(value);
229
229
  };
230
230
  const onKey = (str, key) => {
231
231
  if (key?.ctrl && key.name === "c") {
@@ -315,14 +315,14 @@ async function select(question, choices, options = {}) {
315
315
  `);
316
316
  hideCursor();
317
317
  render(true);
318
- return await new Promise((resolve4) => {
318
+ return await new Promise((resolve5) => {
319
319
  const wasRaw = stdin.isRaw;
320
320
  const finish = (value) => {
321
321
  stdin.removeListener("keypress", onKey);
322
322
  stdin.setRawMode(wasRaw ?? false);
323
323
  stdin.pause();
324
324
  showCursor();
325
- resolve4(value);
325
+ resolve5(value);
326
326
  };
327
327
  const move = (delta) => {
328
328
  let next = cursor;
@@ -414,14 +414,14 @@ async function multiSelect(question, choices, options = {}) {
414
414
  `);
415
415
  hideCursor();
416
416
  render(true);
417
- return await new Promise((resolve4) => {
417
+ return await new Promise((resolve5) => {
418
418
  const wasRaw = stdin.isRaw;
419
419
  const finish = () => {
420
420
  stdin.removeListener("keypress", onKey);
421
421
  stdin.setRawMode(wasRaw ?? false);
422
422
  stdin.pause();
423
423
  showCursor();
424
- resolve4([...selected].sort((a, b) => a - b).map((i) => choices[i].value));
424
+ resolve5([...selected].sort((a, b) => a - b).map((i) => choices[i].value));
425
425
  };
426
426
  const onKey = (str, key) => {
427
427
  if (key?.ctrl && key.name === "c") {
@@ -705,6 +705,68 @@ var init_cf_api = __esm({
705
705
  async createKvNamespace(accountId, title) {
706
706
  return await this.request("POST", `/accounts/${accountId}/storage/kv/namespaces`, { title });
707
707
  }
708
+ /* ---------------------------------------------------------------- */
709
+ /* D1(盲中继 / 云监测台) */
710
+ /* ---------------------------------------------------------------- */
711
+ /**
712
+ * 创建 D1 数据库(POST /accounts/{id}/d1/database,权限 D1 Edit)。
713
+ *
714
+ * 盲中继/监测台的硬编码 D1 ID(别人账户的库)必须换成部署时动态建库。
715
+ * 返回 result.uuid 即 database_id,用于 Worker 的 d1 绑定与后续 query。
716
+ */
717
+ async createD1Database(accountId, name) {
718
+ return await this.request("POST", `/accounts/${accountId}/d1/database`, { name });
719
+ }
720
+ /** 列出账号下的 D1 数据库(用于重名检测 / 复用) */
721
+ async listD1Databases(accountId, name) {
722
+ const query = name ? `?name=${encodeURIComponent(name)}` : "";
723
+ return await this.request("GET", `/accounts/${accountId}/d1/database${query}`);
724
+ }
725
+ /**
726
+ * 在 D1 上执行一条 SQL(POST .../d1/database/{id}/query,body {sql})。
727
+ *
728
+ * 用于初始化 schema(CREATE TABLE IF NOT EXISTS 幂等)。DDL 无结果行,
729
+ * 但 Cloudflare 仍会返回 `{ results: [], success: true }`;非 2xx 会由
730
+ * readApiResponse 抛 CloudflareError,调用方据此判定初始化是否成功。
731
+ */
732
+ async queryD1(accountId, databaseId, sql) {
733
+ const result = await this.request(
734
+ "POST",
735
+ `/accounts/${accountId}/d1/database/${encodeURIComponent(databaseId)}/query`,
736
+ { sql }
737
+ );
738
+ return Array.isArray(result) ? result : [];
739
+ }
740
+ /* ---------------------------------------------------------------- */
741
+ /* Durable Objects(盲中继房间) */
742
+ /* ---------------------------------------------------------------- */
743
+ /**
744
+ * ⚠️ 已废弃:不要调用本方法创建 DO 命名空间。
745
+ *
746
+ * 真机实测(2026-11-17,测试账号):
747
+ * - 只传 {name, class} → `10100: class cannot be set without script`
748
+ * - 传 {name, script, class} → `10099: Creating new key-value backed Durable Object
749
+ * namespaces is no longer supported on this account. Please create a namespace
750
+ * using a `new_sqlite_classes` migration instead.`
751
+ *
752
+ * 正确做法:Worker 上传时带 `migrations: [{ tag, new_sqlite_classes: ['MeshRoom'] }]`,
753
+ * 平台会自动创建 SQLite 后端的 DO 命名空间。见 `uploadScript` 的 migrations 参数。
754
+ *
755
+ * 本方法仅为 API 完整性保留,调用即抛错,防止 Phase 2 误用走不通的路径。
756
+ */
757
+ async createDoNamespace() {
758
+ throw new Error(
759
+ "\u624B\u52A8\u521B\u5EFA DO \u547D\u540D\u7A7A\u95F4\u5DF2\u4E0D\u53D7\u5E73\u53F0\u652F\u6301\uFF08\u9700 new_sqlite_classes migration\uFF09\u3002\u8BF7\u5728 uploadScript \u7684 migrations \u53C2\u6570\u91CC\u58F0\u660E new_sqlite_classes\uFF0C\u7531\u5E73\u53F0\u81EA\u52A8\u521B\u5EFA\u3002"
760
+ );
761
+ }
762
+ /** 列出账号下的 Durable Object 命名空间 */
763
+ async listDoNamespaces(accountId) {
764
+ const result = await this.request(
765
+ "GET",
766
+ `/accounts/${accountId}/workers/durable_objects/namespaces`
767
+ );
768
+ return Array.isArray(result) ? result : [];
769
+ }
708
770
  /**
709
771
  * 读取 KV 里的一个键值(不存在时返回 null)。
710
772
  *
@@ -774,13 +836,27 @@ var init_cf_api = __esm({
774
836
  async listScripts(accountId) {
775
837
  return await this.request("GET", `/accounts/${accountId}/workers/scripts`);
776
838
  }
777
- /** 上传 Worker 脚本(ES module,多段上传) */
839
+ /**
840
+ * 上传 Worker 脚本(ES module,多段上传)。
841
+ *
842
+ * ## Durable Objects 声明方式(真机 2026-11-17 验证)
843
+ * 新版平台用 `exports` 声明 DO 类(declarative DO exports):
844
+ * `{ MeshRoom: { type:'durable-object', state:'created', storage:'sqlite' } }`
845
+ * 这是 wrangler 4 的默认路径。旧 `migrations` 数组在新版解析器下会报
846
+ * `cannot unmarshal array into Metadata.migrations of type reader.ActorMigrations`,
847
+ * 因此优先用 exports;只有显式传 migrations 且无 exports 时才走旧路径(兼容旧账号)。
848
+ */
778
849
  async uploadScript(accountId, scriptName, options) {
779
850
  const metadata = {
780
851
  main_module: options.mainModule,
781
852
  compatibility_date: options.compatibilityDate,
782
853
  bindings: options.bindings
783
854
  };
855
+ if (options.doExports && Object.keys(options.doExports).length > 0) {
856
+ metadata.exports = options.doExports;
857
+ } else if (options.migrations && options.migrations.length > 0) {
858
+ metadata.migrations = options.migrations;
859
+ }
784
860
  const form = new FormData();
785
861
  form.set("metadata", new Blob([JSON.stringify(metadata)], { type: "application/json" }), "metadata.json");
786
862
  form.set(
@@ -1021,6 +1097,26 @@ var init_cf_api = __esm({
1021
1097
  form
1022
1098
  );
1023
1099
  }
1100
+ /**
1101
+ * 上传静态文件部署 Pages(监测面板 index.html 用)。
1102
+ *
1103
+ * 与 deployPagesWorker 的区别:这里直接把文件作为 multipart 段上传,
1104
+ * 不带 _worker.bundle。字段名即文件名(如 index.html)。
1105
+ * 表单结构参考 wrangler 的 pages deploy(branch + manifest + 文件段)。
1106
+ */
1107
+ async deployPagesStatic(accountId, name, files) {
1108
+ const form = new FormData();
1109
+ form.set("branch", "main");
1110
+ form.set("manifest", "{}");
1111
+ for (const [path, content] of Object.entries(files)) {
1112
+ form.set(path, new Blob([content], { type: "text/html" }), path);
1113
+ }
1114
+ return await this.request(
1115
+ "POST",
1116
+ `/accounts/${accountId}/pages/projects/${name}/deployments`,
1117
+ form
1118
+ );
1119
+ }
1024
1120
  /** 查询 Pages 部署状态 */
1025
1121
  async getPagesDeployments(accountId, name) {
1026
1122
  return await this.request("GET", `/accounts/${accountId}/pages/projects/${name}/deployments`);
@@ -2267,6 +2363,7 @@ var init_kernel_remote = __esm({
2267
2363
  // src/deploy/pages-deploy.ts
2268
2364
  var pages_deploy_exports = {};
2269
2365
  __export(pages_deploy_exports, {
2366
+ LEGACY_RESOURCE_DEFAULTS: () => LEGACY_RESOURCE_DEFAULTS,
2270
2367
  MANIFEST_KEY: () => MANIFEST_KEY,
2271
2368
  assertKvOwnership: () => assertKvOwnership,
2272
2369
  deployOnce: () => deployOnce,
@@ -2274,6 +2371,7 @@ __export(pages_deploy_exports, {
2274
2371
  detachAllPagesDomains: () => detachAllPagesDomains,
2275
2372
  inspectKvOwnership: () => inspectKvOwnership,
2276
2373
  listCfPilotNamespaces: () => listCfPilotNamespaces,
2374
+ migrateLegacyResourceDefaults: () => migrateLegacyResourceDefaults,
2277
2375
  readManifest: () => readManifest
2278
2376
  });
2279
2377
  import { randomBytes as randomBytes2, randomUUID } from "node:crypto";
@@ -2408,6 +2506,19 @@ async function assertKvOwnership(client, accountId, namespaceId, options) {
2408
2506
  \u26A0 \u5DF2\u6307\u5B9A\u5F3A\u5236\u8986\u76D6\uFF0C\u7EE7\u7EED\u6267\u884C\u2014\u2014\u539F\u5B9E\u4F8B\u7684\u914D\u7F6E\u5C06\u88AB\u672C\u6B21\u90E8\u7F72\u6539\u5199\u3002`);
2409
2507
  return info;
2410
2508
  }
2509
+ function migrateLegacyResourceDefaults(existing) {
2510
+ const config = { ...existing };
2511
+ const applied = [];
2512
+ for (const rule2 of LEGACY_RESOURCE_DEFAULTS) {
2513
+ const raw = config[rule2.field];
2514
+ if (raw === void 0 || raw === null) continue;
2515
+ const value = Number(raw);
2516
+ if (!Number.isFinite(value) || value !== rule2.legacy) continue;
2517
+ config[rule2.field] = rule2.next;
2518
+ applied.push({ field: rule2.field, from: rule2.legacy, to: rule2.next });
2519
+ }
2520
+ return { config, applied };
2521
+ }
2411
2522
  async function writeEffectiveConfig(client, accountId, namespaceId, effective, options, warnings, log) {
2412
2523
  let existing = {};
2413
2524
  let raw;
@@ -2432,8 +2543,13 @@ async function writeEffectiveConfig(client, accountId, namespaceId, effective, o
2432
2543
  warnings.push("\u65E2\u6709 KV \u914D\u7F6E\u4E0D\u662F\u5408\u6CD5 JSON\uFF0C\u5DF2\u6309\u7A7A\u914D\u7F6E\u91CD\u5199");
2433
2544
  }
2434
2545
  }
2546
+ const migrated = migrateLegacyResourceDefaults(existing);
2547
+ if (migrated.applied.length > 0) {
2548
+ const detail = migrated.applied.map((m) => `${m.field} ${m.from}\u2192${m.to}`).join("\u3001");
2549
+ log(`\xB7 \u5DF2\u5347\u7EA7\u65E7\u9ED8\u8BA4\u8D44\u6E90\u503C\uFF1A${detail}\uFF08\u5982\u9700\u5173\u95ED\u6216\u8C03\u6574\uFF0C\u53EF\u5728\u9762\u677F\u6539\u56DE\uFF09`);
2550
+ }
2435
2551
  const merged = {
2436
- ...existing,
2552
+ ...migrated.config,
2437
2553
  uuid: effective.uuid,
2438
2554
  trojanPassword: effective.trojanPassword,
2439
2555
  wsPath: effective.wsPath,
@@ -3073,7 +3189,7 @@ async function deployOnce(params) {
3073
3189
  }
3074
3190
  return null;
3075
3191
  }
3076
- var MANIFEST_KEY;
3192
+ var MANIFEST_KEY, LEGACY_RESOURCE_DEFAULTS;
3077
3193
  var init_pages_deploy = __esm({
3078
3194
  "src/deploy/pages-deploy.ts"() {
3079
3195
  "use strict";
@@ -3084,6 +3200,10 @@ var init_pages_deploy = __esm({
3084
3200
  init_version_util();
3085
3201
  init_version();
3086
3202
  MANIFEST_KEY = "CFP_DEPLOY_MANIFEST";
3203
+ LEGACY_RESOURCE_DEFAULTS = [
3204
+ { field: "dataBudgetMB", legacy: 0, next: 512 },
3205
+ { field: "relayRedialMax", legacy: 4, next: 2 }
3206
+ ];
3087
3207
  }
3088
3208
  });
3089
3209
 
@@ -3767,6 +3887,26 @@ function isRegionGroup(code) {
3767
3887
  function countryOfColo(colo) {
3768
3888
  return coloToCountry.get(colo.toUpperCase()) ?? "";
3769
3889
  }
3890
+ function colosCanUseIPv6(want) {
3891
+ if (want.size === 0) return true;
3892
+ for (const colo of want) {
3893
+ if (IPV6_ACTIVE_COLOS.has(colo.toUpperCase())) return true;
3894
+ }
3895
+ return false;
3896
+ }
3897
+ function colosOfCountryFilter(countries) {
3898
+ const out2 = /* @__PURE__ */ new Set();
3899
+ for (const code of normalizeCountryFilter(countries)) {
3900
+ for (const colo of COUNTRY_COLOS[code] ?? []) out2.add(colo);
3901
+ }
3902
+ for (const raw of countries) {
3903
+ const code = String(raw ?? "").trim().toUpperCase();
3904
+ if (!isKnownCountry(code) && !isRegionGroup(code) && code.length === 3 && countryOfColo(code) === "") {
3905
+ out2.add(code);
3906
+ }
3907
+ }
3908
+ return out2;
3909
+ }
3770
3910
  function isKnownCountry(code) {
3771
3911
  return Object.prototype.hasOwnProperty.call(COUNTRY_COLOS, code.toUpperCase());
3772
3912
  }
@@ -3795,7 +3935,7 @@ function normalizeCountryFilter(input) {
3795
3935
  function coloCity(colo) {
3796
3936
  return COLO_CITIES[colo.toUpperCase()] ?? "";
3797
3937
  }
3798
- var COUNTRY_COLOS, REGION_GROUPS, REGION_GROUP_NAMES, coloToCountry, SUPPORTED_COUNTRIES, COLO_CITIES;
3938
+ var COUNTRY_COLOS, REGION_GROUPS, REGION_GROUP_NAMES, coloToCountry, IPV6_ACTIVE_COLOS, SUPPORTED_COUNTRIES, COLO_CITIES;
3799
3939
  var init_countries = __esm({
3800
3940
  "src/scan/countries.ts"() {
3801
3941
  "use strict";
@@ -3847,6 +3987,7 @@ var init_countries = __esm({
3847
3987
  for (const [country, colos] of Object.entries(COUNTRY_COLOS)) {
3848
3988
  for (const colo of colos) coloToCountry.set(colo, country);
3849
3989
  }
3990
+ IPV6_ACTIVE_COLOS = /* @__PURE__ */ new Set(["AMS", "FRA", "SIN", "SJC"]);
3850
3991
  SUPPORTED_COUNTRIES = Object.keys(COUNTRY_COLOS);
3851
3992
  COLO_CITIES = {
3852
3993
  HKG: "\u9999\u6E2F",
@@ -3922,15 +4063,15 @@ var init_countries = __esm({
3922
4063
 
3923
4064
  // src/scan/true-probe.ts
3924
4065
  import * as tls from "node:tls";
3925
- import * as crypto from "node:crypto";
4066
+ import * as crypto2 from "node:crypto";
3926
4067
  function extractColo(text2) {
3927
4068
  const match = /cf-ray:\s*[0-9a-f]+-([A-Z]{3})/i.exec(text2);
3928
4069
  return match ? match[1].toUpperCase() : "";
3929
4070
  }
3930
4071
  function probeWs101(ip, port, host, timeoutMs = 3e3, path = "/__edge_probe") {
3931
- return new Promise((resolve4) => {
4072
+ return new Promise((resolve5) => {
3932
4073
  const started = Date.now();
3933
- const key = crypto.randomBytes(16).toString("base64");
4074
+ const key = crypto2.randomBytes(16).toString("base64");
3934
4075
  let settled = false;
3935
4076
  let received = "";
3936
4077
  const finish = (result) => {
@@ -3941,7 +4082,7 @@ function probeWs101(ip, port, host, timeoutMs = 3e3, path = "/__edge_probe") {
3941
4082
  socket.destroy();
3942
4083
  } catch {
3943
4084
  }
3944
- resolve4({ ...result, latencyMs: Date.now() - started });
4085
+ resolve5({ ...result, latencyMs: Date.now() - started });
3945
4086
  };
3946
4087
  const request3 = [
3947
4088
  `GET ${path} HTTP/1.1`,
@@ -3996,7 +4137,7 @@ function probeWs101(ip, port, host, timeoutMs = 3e3, path = "/__edge_probe") {
3996
4137
  });
3997
4138
  }
3998
4139
  function encodeWsFrame(payload, opcode = 2) {
3999
- const mask = crypto.randomBytes(4);
4140
+ const mask = crypto2.randomBytes(4);
4000
4141
  const masked = Buffer.alloc(payload.length);
4001
4142
  for (let i = 0; i < payload.length; i++) {
4002
4143
  masked[i] = payload[i] ^ mask[i % 4];
@@ -4044,9 +4185,9 @@ function decodeWsFrame(buf) {
4044
4185
  return { frame, rest };
4045
4186
  }
4046
4187
  function probeWsPing(ip, port, host, timeoutMs = 5e3, path = "/__edge_probe") {
4047
- return new Promise((resolve4) => {
4188
+ return new Promise((resolve5) => {
4048
4189
  const started = Date.now();
4049
- const key = crypto.randomBytes(16).toString("base64");
4190
+ const key = crypto2.randomBytes(16).toString("base64");
4050
4191
  let settled = false;
4051
4192
  let handshakeDone = false;
4052
4193
  let buf = Buffer.alloc(0);
@@ -4059,7 +4200,7 @@ function probeWsPing(ip, port, host, timeoutMs = 5e3, path = "/__edge_probe") {
4059
4200
  socket.destroy();
4060
4201
  } catch {
4061
4202
  }
4062
- resolve4({ ...result, latencyMs: Date.now() - started });
4203
+ resolve5({ ...result, latencyMs: Date.now() - started });
4063
4204
  };
4064
4205
  const request3 = [
4065
4206
  `GET ${path} HTTP/1.1`,
@@ -4170,7 +4311,7 @@ function probeWsPing(ip, port, host, timeoutMs = 5e3, path = "/__edge_probe") {
4170
4311
  });
4171
4312
  }
4172
4313
  function probeTlsHandshake(ip, port, host, timeoutMs = 4e3, alpn = "http/1.1") {
4173
- return new Promise((resolve4) => {
4314
+ return new Promise((resolve5) => {
4174
4315
  const started = Date.now();
4175
4316
  let settled = false;
4176
4317
  const finish = (result) => {
@@ -4181,7 +4322,7 @@ function probeTlsHandshake(ip, port, host, timeoutMs = 4e3, alpn = "http/1.1") {
4181
4322
  socket.destroy();
4182
4323
  } catch {
4183
4324
  }
4184
- resolve4({ ip, tlsMs: result.tlsMs ?? Date.now() - started, ...result });
4325
+ resolve5({ ip, tlsMs: result.tlsMs ?? Date.now() - started, ...result });
4185
4326
  };
4186
4327
  const expect = alpn === "h2" ? "h2" : "http/1.1";
4187
4328
  const socket = tls.connect(
@@ -4222,7 +4363,7 @@ function measureThroughput(options) {
4222
4363
  minBytes = 32 * 1024
4223
4364
  } = options;
4224
4365
  const connCount = Math.max(1, Math.min(16, connections));
4225
- return new Promise((resolve4) => {
4366
+ return new Promise((resolve5) => {
4226
4367
  const started = Date.now();
4227
4368
  let settled = false;
4228
4369
  const meter = new WindowMeter({ startedAt: started, warmupMs, windowMs });
@@ -4254,7 +4395,7 @@ function measureThroughput(options) {
4254
4395
  else if (totalBytes === 0) error = lastError || "\u672A\u6536\u5230\u6570\u636E";
4255
4396
  else error = lastError || `\u8F7D\u8377\u4E0D\u8DB3\uFF08${totalBytes}/${minBytes} \u5B57\u8282\uFF09`;
4256
4397
  }
4257
- resolve4({
4398
+ resolve5({
4258
4399
  ok,
4259
4400
  bytes: totalBytes,
4260
4401
  ms: now - started,
@@ -4327,6 +4468,17 @@ function measureThroughput(options) {
4327
4468
  finish();
4328
4469
  return;
4329
4470
  }
4471
+ if (requiredHeader) {
4472
+ const headerLine = head.split("\r\n").find((l) => l.toLowerCase().startsWith(`${requiredHeader.toLowerCase()}:`));
4473
+ const declared = Number.parseInt(headerLine?.split(":")[1]?.trim() ?? "", 10);
4474
+ if (!Number.isFinite(declared) || declared < 1024 * 1024) {
4475
+ headerMismatch = true;
4476
+ lastError = `\u76EE\u6807\u63A2\u9488\u54CD\u5E94\u5934\u5F02\u5E38\uFF08${requiredHeader}=${headerLine?.split(":")[1]?.trim() ?? "\u7A7A"}\uFF09\uFF0C\u53EF\u6539\u7528 --speed-mode url`;
4477
+ socket.destroy();
4478
+ finish();
4479
+ return;
4480
+ }
4481
+ }
4330
4482
  headerDone = true;
4331
4483
  const body = headerBuffer.subarray(idx + 4);
4332
4484
  meter.add(body.byteLength);
@@ -4385,7 +4537,7 @@ function buildVlessTunnelPayload(uuid, targetHost, targetPort, request3) {
4385
4537
  ]);
4386
4538
  }
4387
4539
  function buildTrojanTunnelPayload(password, targetHost, targetPort, request3) {
4388
- const digest = crypto.createHash("sha224").update(password).digest("hex");
4540
+ const digest = crypto2.createHash("sha224").update(password).digest("hex");
4389
4541
  const hostBuf = Buffer.from(targetHost, "utf8");
4390
4542
  return Buffer.concat([
4391
4543
  Buffer.from(digest + "\r\n", "ascii"),
@@ -4406,9 +4558,9 @@ function verifyTunnel(options) {
4406
4558
  const { ip, port, host, wsPath, uuid, trojanPassword, targetHost = "baidu.com", targetPort = 80, timeoutMs = 8e3 } = options;
4407
4559
  const payload = uuid ? buildVlessTunnelPayload(uuid, targetHost, targetPort, tunnelTargetRequest(targetHost)) : trojanPassword ? buildTrojanTunnelPayload(trojanPassword, targetHost, targetPort, tunnelTargetRequest(targetHost)) : null;
4408
4560
  if (!payload) return Promise.resolve({ ok: false, stage: "protocol", latencyMs: 0, error: "\u7F3A\u5C11 uuid / trojanPassword" });
4409
- return new Promise((resolve4) => {
4561
+ return new Promise((resolve5) => {
4410
4562
  const started = Date.now();
4411
- const key = crypto.randomBytes(16).toString("base64");
4563
+ const key = crypto2.randomBytes(16).toString("base64");
4412
4564
  let settled = false;
4413
4565
  let handshakeDone = false;
4414
4566
  let buf = Buffer.alloc(0);
@@ -4420,7 +4572,7 @@ function verifyTunnel(options) {
4420
4572
  socket.destroy();
4421
4573
  } catch {
4422
4574
  }
4423
- resolve4({ ...r, latencyMs: Date.now() - started });
4575
+ resolve5({ ...r, latencyMs: Date.now() - started });
4424
4576
  };
4425
4577
  const socket = tls.connect({ host: ip, port, servername: host, rejectUnauthorized: false, ALPNProtocols: ["http/1.1"] }, () => {
4426
4578
  socket.write(tunnelUpgradeRequest(host, wsPath, key));
@@ -4470,7 +4622,7 @@ function verifyTunnel(options) {
4470
4622
  });
4471
4623
  }
4472
4624
  function randomXhttpSession() {
4473
- return "sess-" + crypto.randomBytes(8).toString("hex");
4625
+ return "sess-" + crypto2.randomBytes(8).toString("hex");
4474
4626
  }
4475
4627
  function h2Authority(ip, port) {
4476
4628
  return `https://${ip.includes(":") ? `[${ip}]` : ip}:${port}`;
@@ -4481,7 +4633,7 @@ function extractColoFromHeaders(headers) {
4481
4633
  return m ? m[1] : "";
4482
4634
  }
4483
4635
  function probeXhttpEndpoint(ip, port, host, xhttpPath, timeoutMs = 3e3) {
4484
- return new Promise((resolve4) => {
4636
+ return new Promise((resolve5) => {
4485
4637
  void (async () => {
4486
4638
  const started = Date.now();
4487
4639
  const session = randomXhttpSession();
@@ -4500,7 +4652,7 @@ function probeXhttpEndpoint(ip, port, host, xhttpPath, timeoutMs = 3e3) {
4500
4652
  client?.destroy();
4501
4653
  } catch {
4502
4654
  }
4503
- resolve4({ ...r, latencyMs: Date.now() - started });
4655
+ resolve5({ ...r, latencyMs: Date.now() - started });
4504
4656
  };
4505
4657
  const timer = setTimeout(() => {
4506
4658
  finish({ ok: false, colo: "", status: 0, error: "XHTTP \u63E1\u624B\u8D85\u65F6" });
@@ -4566,7 +4718,7 @@ function verifyXhttpTunnel(options) {
4566
4718
  if (!payload) {
4567
4719
  return Promise.resolve({ ok: false, stage: "protocol", latencyMs: 0, error: "\u7F3A\u5C11 uuid" });
4568
4720
  }
4569
- return new Promise((resolve4) => {
4721
+ return new Promise((resolve5) => {
4570
4722
  void (async () => {
4571
4723
  const started = Date.now();
4572
4724
  const session = randomXhttpSession();
@@ -4585,7 +4737,7 @@ function verifyXhttpTunnel(options) {
4585
4737
  client?.destroy();
4586
4738
  } catch {
4587
4739
  }
4588
- resolve4({ ...r, latencyMs: Date.now() - started });
4740
+ resolve5({ ...r, latencyMs: Date.now() - started });
4589
4741
  };
4590
4742
  const timer = setTimeout(() => {
4591
4743
  finish({
@@ -4846,7 +4998,7 @@ function schemeForPort(port) {
4846
4998
  return port === 443 || port === 2053 || port === 2083 || port === 2087 || port === 2096 || port === 8443 ? "https" : "http";
4847
4999
  }
4848
5000
  function checkSpeedUrlAvailable(parsed, timeoutMs = 6e3) {
4849
- return new Promise((resolve4) => {
5001
+ return new Promise((resolve5) => {
4850
5002
  let settled = false;
4851
5003
  let received = "";
4852
5004
  const finish = (available, status2, error) => {
@@ -4857,7 +5009,7 @@ function checkSpeedUrlAvailable(parsed, timeoutMs = 6e3) {
4857
5009
  socket.destroy();
4858
5010
  } catch {
4859
5011
  }
4860
- resolve4({ available, status: status2, error });
5012
+ resolve5({ available, status: status2, error });
4861
5013
  };
4862
5014
  const path = parsed.path.includes("bytes=") ? parsed.path.replace(/bytes=\d+/, "bytes=1024") : parsed.path;
4863
5015
  const request3 = [
@@ -4938,7 +5090,7 @@ var init_speed_url = __esm({
4938
5090
  import * as tls3 from "node:tls";
4939
5091
  function probeUnlock(options) {
4940
5092
  const { ip, port = 443, host, token, timeoutMs = 12e3 } = options;
4941
- return new Promise((resolve4) => {
5093
+ return new Promise((resolve5) => {
4942
5094
  let settled = false;
4943
5095
  let raw = Buffer.alloc(0);
4944
5096
  const finish = (result) => {
@@ -4948,7 +5100,7 @@ function probeUnlock(options) {
4948
5100
  socket.destroy();
4949
5101
  } catch {
4950
5102
  }
4951
- resolve4(result);
5103
+ resolve5(result);
4952
5104
  };
4953
5105
  const socket = tls3.connect(
4954
5106
  {
@@ -5571,7 +5723,7 @@ function countFailure(into, stage, error) {
5571
5723
  bucket[key] = (bucket[key] ?? 0) + 1;
5572
5724
  }
5573
5725
  async function tcpPing(ip, port, timeoutMs) {
5574
- return new Promise((resolve4) => {
5726
+ return new Promise((resolve5) => {
5575
5727
  const started = Date.now();
5576
5728
  let settled = false;
5577
5729
  const socket = new net2.Socket();
@@ -5582,7 +5734,7 @@ async function tcpPing(ip, port, timeoutMs) {
5582
5734
  socket.destroy();
5583
5735
  } catch {
5584
5736
  }
5585
- resolve4({ ip, ok, latency: Date.now() - started });
5737
+ resolve5({ ip, ok, latency: Date.now() - started });
5586
5738
  };
5587
5739
  socket.setTimeout(timeoutMs, () => done(false));
5588
5740
  socket.once("connect", () => done(true));
@@ -5883,7 +6035,7 @@ async function runScan(options) {
5883
6035
  }
5884
6036
  let wsFiltered = wsOk;
5885
6037
  let appliedCountries = [];
5886
- let countryFilterRelaxed = false;
6038
+ let countryFilterNoMatch = false;
5887
6039
  if (hasCountryFilter && wsOk.length > 0) {
5888
6040
  const matched = wsOk.filter((r) => countryFilter.includes(countryOfColo(r.colo || r.probe?.colo || "")));
5889
6041
  if (matched.length > 0) {
@@ -5897,14 +6049,17 @@ async function runScan(options) {
5897
6049
  message: `\u56FD\u5BB6\u7B5B\u9009 ${countryFilter.join("/")}\uFF1A\u4FDD\u7559 ${matched.length}/${wsOk.length}\uFF0C\u8FDB\u5165\u6D4B\u901F`
5898
6050
  });
5899
6051
  } else {
5900
- countryFilterRelaxed = true;
6052
+ countryFilterNoMatch = true;
5901
6053
  report({
5902
6054
  type: "progress",
5903
6055
  stage: 2,
5904
6056
  done: wsOk.length,
5905
6057
  total: wsOk.length,
5906
- message: `\u26A0\uFE0F \u56FD\u5BB6\u7B5B\u9009 ${countryFilter.join("/")} \u540E\u65E0\u5019\u9009 \u2014\u2014 \u5DF2\u653E\u5BBD\u4E3A\u5168\u91CF\uFF08${wsOk.length} \u6761\uFF09\u3002\u53EF\u52A0\u5927 --sample \u6216\u6362\u5730\u533A\u91CD\u8BD5`
6058
+ message: `\u56FD\u5BB6\u7B5B\u9009 ${countryFilter.join("/")} \u540E 0 \u547D\u4E2D\uFF08${wsOk.length} \u4E2A\u53EF\u7528\u8282\u70B9\u5747\u4E0D\u5728\u6240\u9009\u673A\u623F\uFF09\uFF0C\u672A\u653E\u5BBD\u4E3A\u5176\u5B83\u5730\u533A`
5907
6059
  });
6060
+ throw new Error(
6061
+ `\u6240\u9009\u5730\u533A\u672C\u8F6E 0 \u547D\u4E2D\uFF1A${wsOk.length} \u4E2A\u53EF\u7528\u8282\u70B9\u5747\u843D\u5728\u5176\u5B83\u673A\u623F\uFF0C\u672A\u653E\u5BBD\u4E3A\u5176\u5B83\u5730\u533A\u3002\u53EF\u52A0\u5927 --sample \u6216\u6362\u4E00\u4E2A\u5730\u533A\u91CD\u8BD5`
6062
+ );
5908
6063
  }
5909
6064
  }
5910
6065
  const rankedByLatency = wsFiltered.sort(
@@ -6104,8 +6259,10 @@ async function runScan(options) {
6104
6259
  elapsedMs: Date.now() - started,
6105
6260
  countries: appliedCountries,
6106
6261
  wsFiltered: wsFiltered.length,
6107
- /** 国家筛选未命中任何候选、已放宽为全量 */
6108
- countryFilterRelaxed,
6262
+ /** 国家筛选未命中任何候选、已放宽为全量(严格模式下恒为 false,会直接抛错) */
6263
+ countryFilterRelaxed: false,
6264
+ /** 国家筛选 0 命中、严格不放宽(保留字段供调用方兼容,实际本轮已抛错) */
6265
+ countryFilterNoMatch,
6109
6266
  /** 因已攒够目标国家节点而提前结束阶段二 */
6110
6267
  stoppedEarly,
6111
6268
  /** 各阶段失败原因分布 */
@@ -6438,7 +6595,7 @@ var init_callback = __esm({
6438
6595
  import * as net3 from "node:net";
6439
6596
  import { execFile } from "node:child_process";
6440
6597
  function isPortListening(port, timeoutMs = 400) {
6441
- return new Promise((resolve4) => {
6598
+ return new Promise((resolve5) => {
6442
6599
  const socket = new net3.Socket();
6443
6600
  let settled = false;
6444
6601
  const done = (open2) => {
@@ -6448,7 +6605,7 @@ function isPortListening(port, timeoutMs = 400) {
6448
6605
  socket.destroy();
6449
6606
  } catch {
6450
6607
  }
6451
- resolve4(open2);
6608
+ resolve5(open2);
6452
6609
  };
6453
6610
  socket.setTimeout(timeoutMs, () => done(false));
6454
6611
  socket.once("connect", () => done(true));
@@ -6462,12 +6619,12 @@ function isPortListening(port, timeoutMs = 400) {
6462
6619
  }
6463
6620
  async function readSystemProxy() {
6464
6621
  if (process.platform !== "win32") return "";
6465
- const query = (key) => new Promise((resolve4) => {
6622
+ const query = (key) => new Promise((resolve5) => {
6466
6623
  execFile(
6467
6624
  "reg",
6468
6625
  ["query", "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings", "/v", key],
6469
6626
  { timeout: 3e3, windowsHide: true },
6470
- (err, stdout2) => resolve4(err ? "" : String(stdout2))
6627
+ (err, stdout2) => resolve5(err ? "" : String(stdout2))
6471
6628
  );
6472
6629
  });
6473
6630
  try {
@@ -6546,8 +6703,8 @@ async function detectProxyInterference(host) {
6546
6703
  }
6547
6704
  const probeHost = host?.trim() || "www.cloudflare.com";
6548
6705
  try {
6549
- const { resolve4 } = await import("node:dns/promises");
6550
- const ips = await resolve4(probeHost).catch(() => []);
6706
+ const { resolve4: resolve42 } = await import("node:dns/promises");
6707
+ const ips = await resolve42(probeHost).catch(() => []);
6551
6708
  const fake = ips.find((ip) => isFakeIp(ip));
6552
6709
  if (fake) {
6553
6710
  findings.push({
@@ -7110,10 +7267,10 @@ function findGlobalIPv6() {
7110
7267
  }
7111
7268
  async function probeDefaultRoute(timeoutMs = 800) {
7112
7269
  const platform = process.platform;
7113
- const run = (cmd, args) => new Promise((resolve4, reject) => {
7270
+ const run = (cmd, args) => new Promise((resolve5, reject) => {
7114
7271
  const child = execFile2(cmd, args, { timeout: timeoutMs, windowsHide: true, maxBuffer: 1 << 20 }, (err, stdout2) => {
7115
7272
  if (err && !stdout2) reject(err);
7116
- else resolve4(String(stdout2 ?? ""));
7273
+ else resolve5(String(stdout2 ?? ""));
7117
7274
  });
7118
7275
  child.on("error", reject);
7119
7276
  });
@@ -7133,7 +7290,7 @@ async function probeDefaultRoute(timeoutMs = 800) {
7133
7290
  }
7134
7291
  }
7135
7292
  function tcpReachable(address, port, timeoutMs) {
7136
- return new Promise((resolve4) => {
7293
+ return new Promise((resolve5) => {
7137
7294
  let settled = false;
7138
7295
  const done = (ok) => {
7139
7296
  if (settled) return;
@@ -7142,7 +7299,7 @@ function tcpReachable(address, port, timeoutMs) {
7142
7299
  socket.destroy();
7143
7300
  } catch {
7144
7301
  }
7145
- resolve4(ok);
7302
+ resolve5(ok);
7146
7303
  };
7147
7304
  const socket = new net4.Socket();
7148
7305
  socket.setTimeout(timeoutMs, () => done(false));
@@ -7331,12 +7488,12 @@ async function discoverIPv6Prefixes(hosts, timeoutMs = 6e3) {
7331
7488
  return [...out2].sort();
7332
7489
  }
7333
7490
  function withTimeout(promise, ms) {
7334
- return new Promise((resolve4, reject) => {
7491
+ return new Promise((resolve5, reject) => {
7335
7492
  const timer = setTimeout(() => reject(new Error("timeout")), ms);
7336
7493
  promise.then(
7337
7494
  (value) => {
7338
7495
  clearTimeout(timer);
7339
- resolve4(value);
7496
+ resolve5(value);
7340
7497
  },
7341
7498
  (error) => {
7342
7499
  clearTimeout(timer);
@@ -7668,12 +7825,12 @@ function startBridge(options = {}) {
7668
7825
  sendJson(res, 500, { ok: false, error: err instanceof Error ? err.message : String(err) });
7669
7826
  });
7670
7827
  });
7671
- return new Promise((resolve4, reject) => {
7828
+ return new Promise((resolve5, reject) => {
7672
7829
  server.once("error", reject);
7673
7830
  server.listen(port, host, () => {
7674
7831
  const address = server.address();
7675
7832
  const boundPort = typeof address === "object" && address !== null ? address.port : port;
7676
- resolve4({
7833
+ resolve5({
7677
7834
  server,
7678
7835
  port: boundPort,
7679
7836
  token,
@@ -7968,7 +8125,8 @@ scan \u9009\u9879:
7968
8125
  \u673A\u623F\u6765\u81EA 101 \u63E1\u624B\u54CD\u5E94\u3002
7969
8126
  \u5E26\u6B64\u53C2\u6570\u4F1A\u81EA\u52A8\u6269\u5927 101 \u6821\u9A8C\u7684\u5019\u9009\u6C60\uFF08120 \u2192 \u6700\u591A 500\uFF09\uFF0C
7970
8127
  \u5426\u5219\u76EE\u6807\u5730\u533A\u53EF\u80FD\u56E0\u5EF6\u8FDF\u6392\u5E8F\u88AB\u63D0\u524D\u622A\u65AD\uFF1B
7971
- \u7B5B\u4E0D\u5230\u65F6\u4F1A\u660E\u786E\u63D0\u793A\u300C\u5DF2\u653E\u5BBD\u4E3A\u5168\u91CF\u300D\u800C\u4E0D\u662F\u9759\u9ED8\u5FFD\u7565
8128
+ \u6240\u9009\u673A\u623F\u5728 IPv6 \u6D3B\u8DC3\u6BB5\u6CA1\u6709\u5BF9\u5E94\u65F6\u4F1A\u81EA\u52A8\u8DF3\u8FC7 IPv6\uFF08\u4E1C\u4E9A\u673A\u623F\u65E0 v6 \u6BB5\uFF09\uFF1B
8129
+ \u7B5B\u4E0D\u5230\u65F6\u660E\u786E\u62A5\u9519\u300C0 \u547D\u4E2D\u3001\u672A\u653E\u5BBD\u300D\uFF0C\u4E0D\u4F1A\u6DF7\u5165\u5176\u5B83\u5730\u533A\u8282\u70B9
7972
8130
  --min-speed <MB/s> \u4E0B\u884C\u901F\u5EA6\u4E0B\u9650\uFF0C\u9ED8\u8BA4 0\uFF08\u4E0D\u8FC7\u6EE4\uFF09
7973
8131
  \u6309**\u7A33\u6001**\u4E0B\u884C\u901F\u5EA6\u6DD8\u6C70\uFF0C\u5355\u4F4D MB/s\uFF0C0.1 \u5373\u53EF\u8FC7\u6EE4\u6389
7974
8132
  \u7EDD\u5927\u591A\u6570\u300C\u63E1\u624B\u80FD\u8FC7\u4F46\u5E26\u5BBD\u4E0D\u53EF\u7528\u300D\u7684 IP\u3002
@@ -8425,7 +8583,7 @@ var init_pool2 = __esm({
8425
8583
  V6_NETS = BUILTIN_IPV6_CIDRS.map(parseCidr).filter(
8426
8584
  (v) => v !== null && v.family === 6
8427
8585
  );
8428
- sleep = (ms) => new Promise((resolve4) => setTimeout(resolve4, ms));
8586
+ sleep = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
8429
8587
  }
8430
8588
  });
8431
8589
 
@@ -8953,7 +9111,7 @@ function withTimeout2(promise, ms, label) {
8953
9111
  ]);
8954
9112
  }
8955
9113
  function openTunnel(wsUrl, uuid, ip, port, timeoutMs) {
8956
- return new Promise((resolve4, reject) => {
9114
+ return new Promise((resolve5, reject) => {
8957
9115
  const started = Date.now();
8958
9116
  const ws = new WebSocket(wsUrl);
8959
9117
  ws.binaryType = "arraybuffer";
@@ -8981,7 +9139,7 @@ function openTunnel(wsUrl, uuid, ip, port, timeoutMs) {
8981
9139
  clearTimeout(timer);
8982
9140
  const rest = bytes.subarray(Math.min(headerLen, bytes.byteLength));
8983
9141
  if (rest.byteLength > 0) push(rest);
8984
- resolve4({ ws, duplex, tunnelMs: Date.now() - started, first: sniff });
9142
+ resolve5({ ws, duplex, tunnelMs: Date.now() - started, first: sniff });
8985
9143
  return;
8986
9144
  }
8987
9145
  if (sniff.first.length === 0) sniff.first = Buffer.from(bytes);
@@ -9006,7 +9164,7 @@ function openTunnel(wsUrl, uuid, ip, port, timeoutMs) {
9006
9164
  });
9007
9165
  }
9008
9166
  function readHttp(socket, timeoutMs) {
9009
- return new Promise((resolve4, reject) => {
9167
+ return new Promise((resolve5, reject) => {
9010
9168
  let text2 = "";
9011
9169
  let done = false;
9012
9170
  const finish = () => {
@@ -9018,7 +9176,7 @@ function readHttp(socket, timeoutMs) {
9018
9176
  const head = sep >= 0 ? text2.slice(0, sep) : text2;
9019
9177
  const body = sep >= 0 ? text2.slice(sep + 4) : "";
9020
9178
  const matched = /^HTTP\/1\.[01] (\d{3})/.exec(head);
9021
- resolve4({ status: matched ? Number(matched[1]) : 0, body, raw: text2 });
9179
+ resolve5({ status: matched ? Number(matched[1]) : 0, body, raw: text2 });
9022
9180
  };
9023
9181
  const timer = setTimeout(finish, timeoutMs);
9024
9182
  const onData = (chunk) => {
@@ -9068,7 +9226,7 @@ async function probeOne(opts, ip, timeoutMs) {
9068
9226
  out2.tunnelMs = tunnel.tunnelMs;
9069
9227
  const tlsStarted = Date.now();
9070
9228
  socket = await withTimeout2(
9071
- new Promise((resolve4, reject) => {
9229
+ new Promise((resolve5, reject) => {
9072
9230
  const s = tls4.connect(
9073
9231
  {
9074
9232
  socket: tunnel.duplex,
@@ -9077,7 +9235,7 @@ async function probeOne(opts, ip, timeoutMs) {
9077
9235
  // 这一条通过,就等于证明「这个候选确实把 SNI=我们的域名 转到了 CF」。
9078
9236
  rejectUnauthorized: true
9079
9237
  },
9080
- () => resolve4(s)
9238
+ () => resolve5(s)
9081
9239
  );
9082
9240
  s.once("error", reject);
9083
9241
  }),
@@ -9195,7 +9353,7 @@ async function verifyOne(opts, ip, verifyHost, timeoutMs) {
9195
9353
  try {
9196
9354
  const tunnel = await openTunnel(opts.wsUrl, opts.uuid, ip, 443, timeoutMs);
9197
9355
  ws = tunnel.ws;
9198
- socket = await new Promise((resolve4, reject) => {
9356
+ socket = await new Promise((resolve5, reject) => {
9199
9357
  const s = tls4.connect(
9200
9358
  {
9201
9359
  socket: tunnel.duplex,
@@ -9203,7 +9361,7 @@ async function verifyOne(opts, ip, verifyHost, timeoutMs) {
9203
9361
  // 校验网址是公网站点:证书链 + 主机名照常校验
9204
9362
  rejectUnauthorized: true
9205
9363
  },
9206
- () => resolve4(s)
9364
+ () => resolve5(s)
9207
9365
  );
9208
9366
  s.once("error", reject);
9209
9367
  });
@@ -9516,8 +9674,8 @@ var init_relay = __esm({
9516
9674
  ];
9517
9675
  resolve4Async = async (host) => {
9518
9676
  const dns = await import("node:dns");
9519
- return new Promise((resolve4, reject) => {
9520
- dns.resolve4(host, (err, addrs) => err ? reject(err) : resolve4(addrs));
9677
+ return new Promise((resolve5, reject) => {
9678
+ dns.resolve4(host, (err, addrs) => err ? reject(err) : resolve5(addrs));
9521
9679
  });
9522
9680
  };
9523
9681
  WAF_BLOCK_MARKS = /* @__PURE__ */ new Set(["IPv6"]);
@@ -9650,16 +9808,23 @@ async function resolveCandidatesFromArgs(args, extraHosts = [], port = 443) {
9650
9808
  note: ipFile ? `\u5019\u9009\u6765\u81EA\u6587\u4EF6 ${ipFile}\uFF08\u672A\u505A\u7F51\u6BB5\u91C7\u6837\uFF0C\u4E5F\u672A\u505A IPv6 \u9884\u68C0\uFF09` : `\u5019\u9009\u6765\u81EA\u94FE\u63A5 ${ipUrl}\uFF08\u672A\u505A\u7F51\u6BB5\u91C7\u6837\uFF0C\u4E5F\u672A\u505A IPv6 \u9884\u68C0\uFF09`
9651
9809
  };
9652
9810
  }
9811
+ const countryFlags = flagList(args, "countries");
9812
+ const baseFamily = familyFromArgs(args);
9813
+ let family = baseFamily;
9814
+ if (countryFlags.length > 0 && family !== "v4" && !colosCanUseIPv6(colosOfCountryFilter(countryFlags))) {
9815
+ process.stderr.write("\u203B \u6240\u9009\u5730\u533A\u5728 IPv6 \u6D3B\u8DC3\u6BB5\u6CA1\u6709\u5BF9\u5E94\u673A\u623F\uFF0C\u5DF2\u8DF3\u8FC7 IPv6 \u91C7\u6837\uFF08\u907F\u514D\u5176\u5B83\u5730\u533A\u8282\u70B9\u6DF7\u5165\uFF09\n");
9816
+ family = "v4";
9817
+ }
9653
9818
  const base = {
9654
9819
  // 选国家时**自动中性采样**:采样发生在阶段一之前、那时还不知道机房,
9655
9820
  // 若某国家的 IP 集中在低权重网段,候选会被压少 → 可能「扫了几千个还是找不到 HKG/NRT」。
9656
- neutral: args.flags["neutral-sampling"] !== void 0 || flagList(args, "countries").length > 0,
9821
+ neutral: args.flags["neutral-sampling"] !== void 0 || countryFlags.length > 0,
9657
9822
  sample: flagNumber(args, "sample", 6556),
9658
9823
  cidr: flagList(args, "cidr"),
9659
9824
  // ⚠️ 不传 seed = 每次随机(默认)。只有用户显式给了 --seed 才固定,
9660
9825
  // 否则「每次跑都测同一批 IP」——那批落在劣质路由段上时永远测不出好 IP。
9661
9826
  seed: seedFromArgs(args),
9662
- family: familyFromArgs(args),
9827
+ family,
9663
9828
  extraHosts
9664
9829
  };
9665
9830
  if (!flagBool(args, "adaptive")) return resolveCandidatePlan(base);
@@ -10923,6 +11088,817 @@ var init_main = __esm({
10923
11088
  }
10924
11089
  });
10925
11090
 
11091
+ // src/deploy/edge-relay-schema.ts
11092
+ function splitSchemaSql(sql) {
11093
+ const withoutComments = sql.split("\n").filter((line) => !line.trimStart().startsWith("--")).join("\n");
11094
+ return withoutComments.split(";").map((s) => s.trim()).filter((s) => s.length > 0);
11095
+ }
11096
+ var SCHEMA_DEVICES_SQL, SCHEMA_AUTH_SQL, EDGE_RELAY_SCHEMAS;
11097
+ var init_edge_relay_schema = __esm({
11098
+ "src/deploy/edge-relay-schema.ts"() {
11099
+ "use strict";
11100
+ SCHEMA_DEVICES_SQL = `-- \u4E91\u76D1\u6D4B\u53F0 D1 schema\uFF08\u6765\u81EA edge-relay/migrations/0001_init.sql\uFF09
11101
+ CREATE TABLE IF NOT EXISTS devices (
11102
+ node_id TEXT PRIMARY KEY,
11103
+ alias TEXT,
11104
+ virtual_ipv4 TEXT,
11105
+ version TEXT,
11106
+ last_ip TEXT,
11107
+ online INTEGER NOT NULL DEFAULT 0,
11108
+ last_seen_ms INTEGER NOT NULL,
11109
+ updated_at_ms INTEGER NOT NULL
11110
+ );
11111
+ CREATE INDEX IF NOT EXISTS idx_devices_last_seen ON devices(last_seen_ms DESC);`;
11112
+ SCHEMA_AUTH_SQL = `-- \u4E91\u76D1\u6D4B\u53F0\u9274\u6743 D1 schema\uFF08\u6765\u81EA edge-relay/migrations/0002_auth.sql\uFF09
11113
+ CREATE TABLE IF NOT EXISTS auth (
11114
+ id INTEGER PRIMARY KEY,
11115
+ password_hash TEXT,
11116
+ salt TEXT,
11117
+ updated_at_ms INTEGER NOT NULL
11118
+ );
11119
+ CREATE TABLE IF NOT EXISTS sessions (
11120
+ token TEXT PRIMARY KEY,
11121
+ created_at_ms INTEGER NOT NULL,
11122
+ expires_at_ms INTEGER NOT NULL
11123
+ );
11124
+ CREATE INDEX IF NOT EXISTS idx_sessions_expires ON sessions(expires_at_ms);`;
11125
+ EDGE_RELAY_SCHEMAS = [SCHEMA_DEVICES_SQL, SCHEMA_AUTH_SQL];
11126
+ }
11127
+ });
11128
+
11129
+ // src/edge/deploy.ts
11130
+ import { readFileSync as readFileSync6 } from "node:fs";
11131
+ import { resolve as resolve3 } from "node:path";
11132
+ function loadAsset(name) {
11133
+ const candidates = [
11134
+ resolve3(process.cwd(), "assets", "edge-relay", name),
11135
+ resolve3(process.cwd(), "packages", "cli", "assets", "edge-relay", name)
11136
+ ];
11137
+ for (const p of candidates) {
11138
+ try {
11139
+ return readFileSync6(p, "utf8");
11140
+ } catch {
11141
+ }
11142
+ }
11143
+ throw new Error(`\u7F3A\u5C11\u5185\u7F6E\u8D44\u4EA7 assets/edge-relay/${name}\uFF0C\u8BF7\u5148\u8FD0\u884C node scripts/build-edge-relay.mjs`);
11144
+ }
11145
+ function randomToken(bytes = 24) {
11146
+ const arr = new Uint8Array(bytes);
11147
+ crypto.getRandomValues(arr);
11148
+ return Array.from(arr, (b) => b.toString(16).padStart(2, "0")).join("");
11149
+ }
11150
+ function isTransientD1Error(err) {
11151
+ if (err instanceof CloudflareError) {
11152
+ if (err.status === 408 || err.status === 425 || err.status === 429 || err.status >= 500) return true;
11153
+ return /(?:d1|database).*(?:not found|not ready|not available|unavailable|provision)/i.test(err.message);
11154
+ }
11155
+ if (err instanceof TypeError) return true;
11156
+ return err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError");
11157
+ }
11158
+ function errorMessage(err) {
11159
+ return err instanceof Error ? err.message : String(err);
11160
+ }
11161
+ function isTransientHttpStatus(status2) {
11162
+ return status2 === 408 || status2 === 425 || status2 === 429 || status2 >= 500;
11163
+ }
11164
+ async function setupMonitorPasswordWithRetry(workerUrl, password, report) {
11165
+ const deadline = Date.now() + MONITOR_SETUP_TIMEOUT_MS;
11166
+ let delayMs = D1_RETRY_INITIAL_DELAY_MS;
11167
+ let attempts = 0;
11168
+ let lastError = "";
11169
+ while (Date.now() < deadline) {
11170
+ attempts += 1;
11171
+ try {
11172
+ const setupResp = await fetch(`${workerUrl}/auth/setup`, {
11173
+ method: "POST",
11174
+ headers: { "Content-Type": "application/json" },
11175
+ body: JSON.stringify({ password }),
11176
+ signal: AbortSignal.timeout(Math.min(15e3, Math.max(1, deadline - Date.now())))
11177
+ });
11178
+ if (setupResp.ok) {
11179
+ return false;
11180
+ }
11181
+ if (setupResp.status === 409) {
11182
+ return true;
11183
+ }
11184
+ const text2 = await setupResp.text().catch(() => "");
11185
+ lastError = `HTTP ${setupResp.status}: ${text2.slice(0, 300)}`;
11186
+ if (!isTransientHttpStatus(setupResp.status)) {
11187
+ throw new Error(`\u8BBE\u7F6E\u76D1\u6D4B\u53F0\u5BC6\u7801\u5931\u8D25\uFF08${lastError}\uFF09`);
11188
+ }
11189
+ } catch (err) {
11190
+ if (err instanceof Error && err.message.startsWith("\u8BBE\u7F6E\u76D1\u6D4B\u53F0\u5BC6\u7801\u5931\u8D25\uFF08")) throw err;
11191
+ lastError = errorMessage(err);
11192
+ }
11193
+ const remainingMs = deadline - Date.now();
11194
+ if (remainingMs <= 0) break;
11195
+ const waitMs = Math.min(delayMs, remainingMs);
11196
+ report(`Worker/D1 \u5C1A\u672A\u5C31\u7EEA\uFF0C${(waitMs / 1e3).toFixed(waitMs % 1e3 === 0 ? 0 : 1)} \u79D2\u540E\u91CD\u8BD5\u76D1\u6D4B\u53F0\u521D\u59CB\u5316\uFF08\u7B2C ${attempts + 1} \u6B21\uFF09`);
11197
+ await new Promise((resolve5) => setTimeout(resolve5, waitMs));
11198
+ delayMs = Math.min(delayMs * 2, D1_RETRY_MAX_DELAY_MS);
11199
+ }
11200
+ throw new Error(`\u8BBE\u7F6E\u76D1\u6D4B\u53F0\u5BC6\u7801\u5728 ${MONITOR_SETUP_TIMEOUT_MS / 1e3} \u79D2\u5185\u672A\u5B8C\u6210\uFF08\u5DF2\u5C1D\u8BD5 ${attempts} \u6B21\uFF09\uFF1A${lastError}`);
11201
+ }
11202
+ async function queryD1WithRetry(client, accountId, databaseId, sql, deadline, operation, report) {
11203
+ let delayMs = D1_RETRY_INITIAL_DELAY_MS;
11204
+ let attempts = 0;
11205
+ while (true) {
11206
+ attempts += 1;
11207
+ try {
11208
+ await client.queryD1(accountId, databaseId, sql);
11209
+ return;
11210
+ } catch (err) {
11211
+ if (!isTransientD1Error(err)) {
11212
+ throw new Error(`${operation}\u5931\u8D25\uFF1A${errorMessage(err)}`);
11213
+ }
11214
+ const remainingMs = deadline - Date.now();
11215
+ if (remainingMs <= 0) {
11216
+ throw new Error(`${operation}\u5728 ${D1_READY_TIMEOUT_MS / 1e3} \u79D2\u5185\u672A\u5B8C\u6210\uFF08\u5DF2\u91CD\u8BD5 ${attempts - 1} \u6B21\uFF09\uFF1A${errorMessage(err)}`);
11217
+ }
11218
+ const waitMs = Math.min(delayMs, remainingMs);
11219
+ report(`D1 \u6682\u4E0D\u53EF\u7528\uFF0C${(waitMs / 1e3).toFixed(waitMs % 1e3 === 0 ? 0 : 1)} \u79D2\u540E\u91CD\u8BD5${operation}\uFF08\u7B2C ${attempts + 1} \u6B21\uFF09`);
11220
+ await new Promise((resolve5) => setTimeout(resolve5, waitMs));
11221
+ delayMs = Math.min(delayMs * 2, D1_RETRY_MAX_DELAY_MS);
11222
+ }
11223
+ }
11224
+ }
11225
+ async function deployEdgeRelay(client, opts) {
11226
+ const report = opts.onProgress ?? (() => {
11227
+ });
11228
+ const accountId = opts.accountId;
11229
+ const workerName = (opts.workerName || "mobihop-edge-relay").trim();
11230
+ const domain = opts.domain.trim();
11231
+ if (!domain) throw new Error("\u76F2\u4E2D\u7EE7\u5FC5\u987B\u63D0\u4F9B\u81EA\u5B9A\u4E49\u57DF\u540D\uFF08*.workers.dev \u56FD\u5185\u88AB\u6C61\u67D3\uFF09");
11232
+ if (opts.monitorPassword.length < 8) throw new Error("\u76D1\u6D4B\u53F0\u5BC6\u7801\u81F3\u5C11 8 \u4F4D");
11233
+ const workerCode = loadAsset("worker.js");
11234
+ const monitorToken = opts.monitorToken || randomToken();
11235
+ const d1Name = `${workerName}-monitor`;
11236
+ report("\u6B65\u9AA4 1/5\uFF1A\u521B\u5EFA\u76D1\u6D4B\u6570\u636E\u5E93\uFF08D1\uFF09");
11237
+ let db;
11238
+ try {
11239
+ db = await client.createD1Database(accountId, d1Name);
11240
+ } catch (createError) {
11241
+ const existing = await client.listD1Databases(accountId, d1Name).catch(() => []);
11242
+ db = existing.find((candidate) => candidate.name === d1Name);
11243
+ if (!db) throw createError;
11244
+ report(`D1 \u5DF2\u5B58\u5728\uFF0C\u590D\u7528\uFF1A${db.name} (${db.uuid.slice(0, 8)}\u2026)`);
11245
+ }
11246
+ if (!db) throw new Error(`\u521B\u5EFA\u6216\u590D\u7528 D1 \u5931\u8D25\uFF1A${d1Name}`);
11247
+ report(`D1 \u5DF2\u521B\u5EFA\uFF1A${db.name} (${db.uuid.slice(0, 8)}\u2026)\uFF0C\u521D\u59CB\u5316 schema`);
11248
+ const d1Deadline = Date.now() + D1_READY_TIMEOUT_MS;
11249
+ report("\u7B49\u5F85 D1 \u5C31\u7EEA");
11250
+ await queryD1WithRetry(client, accountId, db.uuid, "SELECT 1", d1Deadline, "D1 \u5C31\u7EEA\u68C0\u67E5", report);
11251
+ report("D1 \u5DF2\u5C31\u7EEA\uFF0C\u5F00\u59CB\u521D\u59CB\u5316 schema");
11252
+ for (const schema of EDGE_RELAY_SCHEMAS) {
11253
+ for (const sql of splitSchemaSql(schema)) {
11254
+ await queryD1WithRetry(
11255
+ client,
11256
+ accountId,
11257
+ db.uuid,
11258
+ sql,
11259
+ d1Deadline,
11260
+ `D1 schema \u521D\u59CB\u5316\u5931\u8D25\uFF08${sql.slice(0, 40)}\u2026\uFF09`,
11261
+ report
11262
+ );
11263
+ }
11264
+ }
11265
+ report("D1 schema \u521D\u59CB\u5316\u5B8C\u6210\uFF085 \u6761\u8BED\u53E5\uFF09");
11266
+ report("\u6B65\u9AA4 2/5\uFF1A\u90E8\u7F72\u76F2\u4E2D\u7EE7 Worker\uFF08\u542B Durable Objects \u623F\u95F4\uFF09");
11267
+ const bindings = [
11268
+ { name: "DB", type: "d1", id: db.uuid },
11269
+ { name: "MESH_ROOM", type: "durable_object_namespace", class_name: DEFAULT_DO_CLASS },
11270
+ { name: "MONITOR_TOKEN", type: "plain_text", text: monitorToken },
11271
+ { name: "WINDOW_MS", type: "plain_text", text: opts.limits?.windowMs ?? "1000" },
11272
+ { name: "MAX_BYTES_PER_WINDOW", type: "plain_text", text: opts.limits?.maxBytesPerWindow ?? "1048576" },
11273
+ { name: "MAX_PACKETS_PER_WINDOW", type: "plain_text", text: opts.limits?.maxPacketsPerWindow ?? "2000" },
11274
+ { name: "MAX_PEERS_PER_ROOM", type: "plain_text", text: opts.limits?.maxPeersPerRoom ?? "512" }
11275
+ ];
11276
+ const doExports = {
11277
+ [DEFAULT_DO_CLASS]: { type: "durable-object", state: "created", storage: "sqlite" }
11278
+ };
11279
+ try {
11280
+ await client.uploadScript(accountId, workerName, {
11281
+ mainModule: "worker.js",
11282
+ code: workerCode,
11283
+ compatibilityDate: EDGE_RELAY_COMPAT_DATE,
11284
+ bindings,
11285
+ doExports
11286
+ });
11287
+ } catch (err) {
11288
+ throw new Error(
11289
+ `\u76F2\u4E2D\u7EE7 Worker \u4E0A\u4F20\u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}`
11290
+ );
11291
+ }
11292
+ report("Worker \u5DF2\u4E0A\u4F20\uFF08Durable Objects \u623F\u95F4\u5DF2\u5C31\u7EEA\uFF09");
11293
+ const workerUrl = `https://${domain}`;
11294
+ const wssEndpoint = `wss://${domain}/mesh/<network_hash>?peer_id=<16hex>`;
11295
+ if (opts.zoneId) {
11296
+ report(`\u6B65\u9AA4 3/5\uFF1A\u7ED1\u5B9A\u81EA\u5B9A\u4E49\u57DF\u540D ${domain}`);
11297
+ await client.attachCustomDomain(accountId, {
11298
+ hostname: domain,
11299
+ service: workerName,
11300
+ zoneId: opts.zoneId
11301
+ });
11302
+ report("\u57DF\u540D\u7ED1\u5B9A\u5DF2\u53D7\u7406\uFF08\u9700\u518D\u6821\u9A8C\u771F\u5B9E\u53EF\u8FBE\uFF09");
11303
+ } else {
11304
+ report("\u6B65\u9AA4 3/5\uFF1A\u8DF3\u8FC7\u57DF\u540D\u7ED1\u5B9A\uFF08\u8BF7\u5728 Cloudflare \u63A7\u5236\u53F0\u624B\u52A8\u7ED1\u5B9A\uFF0C\u6216\u63D0\u4F9B --zone-id\uFF09");
11305
+ }
11306
+ report("\u6B65\u9AA4 4/5\uFF1A\u8BBE\u7F6E\u76D1\u6D4B\u53F0\u521D\u59CB\u5BC6\u7801");
11307
+ const monitorAlreadySetup = await setupMonitorPasswordWithRetry(workerUrl, opts.monitorPassword, report);
11308
+ if (monitorAlreadySetup) {
11309
+ report("\u76D1\u6D4B\u53F0\u5DF2\u6709\u5BC6\u7801\uFF0C\u8DF3\u8FC7\u521D\u59CB\u5316\uFF08\u5E42\u7B49\uFF09");
11310
+ } else {
11311
+ report("\u76D1\u6D4B\u53F0\u5BC6\u7801\u5DF2\u8BBE\u7F6E");
11312
+ }
11313
+ let dashboardUrl = null;
11314
+ if (opts.withDashboard !== false) {
11315
+ const project = (opts.dashboardProject || `${workerName}-dashboard`).trim();
11316
+ report(`\u6B65\u9AA4 5/5\uFF1A\u90E8\u7F72\u76D1\u6D4B\u9762\u677F Pages\uFF08${project}\uFF09`);
11317
+ let dashWorkerCode = loadAsset("dashboard-worker.js");
11318
+ dashWorkerCode = dashWorkerCode.replace(
11319
+ /const DEFAULT_API = (?:'[^']*'|location\.origin)/,
11320
+ `const DEFAULT_API = '${workerUrl}'`
11321
+ );
11322
+ await deployDashboard(client, accountId, project, dashWorkerCode, report);
11323
+ dashboardUrl = `https://${project}.pages.dev`;
11324
+ report(`\u76D1\u6D4B\u9762\u677F\u5DF2\u90E8\u7F72\uFF1A${dashboardUrl}`);
11325
+ } else {
11326
+ report("\u6B65\u9AA4 5/5\uFF1A\u8DF3\u8FC7\u76D1\u6D4B\u9762\u677F\u90E8\u7F72");
11327
+ }
11328
+ return {
11329
+ workerName,
11330
+ workerUrl,
11331
+ wssEndpoint,
11332
+ d1Name: db.name,
11333
+ d1Uuid: db.uuid,
11334
+ doClass: DEFAULT_DO_CLASS,
11335
+ dashboardUrl,
11336
+ monitorToken,
11337
+ monitorPassword: opts.monitorPassword
11338
+ };
11339
+ }
11340
+ async function deployDashboard(client, accountId, project, workerCode, report) {
11341
+ try {
11342
+ await client.getPagesProject(accountId, project);
11343
+ } catch (err) {
11344
+ const status2 = typeof err === "object" && err !== null && "status" in err ? err.status : void 0;
11345
+ if (status2 === 404) {
11346
+ await client.createPagesProject(accountId, { name: project });
11347
+ } else {
11348
+ throw err;
11349
+ }
11350
+ }
11351
+ await client.deployPagesWorker(accountId, project, { code: workerCode });
11352
+ report("\u9762\u677F Worker \u5DF2\u4E0A\u4F20");
11353
+ }
11354
+ function formatEdgeDeploySummary(r) {
11355
+ return [
11356
+ "",
11357
+ "================ \u76F2\u4E2D\u7EE7 / \u4E91\u76D1\u6D4B\u53F0\u90E8\u7F72\u5B8C\u6210 ================",
11358
+ `Worker \u540D\u79F0: ${r.workerName}`,
11359
+ `\u76D1\u6D4B API: ${r.workerUrl}`,
11360
+ `WSS \u7AEF\u70B9: ${r.wssEndpoint}`,
11361
+ `D1 \u6570\u636E\u5E93: ${r.d1Name} (${r.d1Uuid.slice(0, 8)}\u2026)`,
11362
+ `Durable Object: ${r.doClass}`,
11363
+ r.dashboardUrl ? `\u76D1\u6D4B\u9762\u677F: ${r.dashboardUrl}` : "\u76D1\u6D4B\u9762\u677F: \uFF08\u672A\u90E8\u7F72\uFF09",
11364
+ `\u4E0A\u62A5\u4EE4\u724C: ${r.monitorToken}`,
11365
+ `\u76D1\u6D4B\u53F0\u5BC6\u7801: ${r.monitorPassword}`,
11366
+ "",
11367
+ "\u8BF7\u59A5\u5584\u4FDD\u5B58\u4E0A\u62A5\u4EE4\u724C\u4E0E\u5BC6\u7801\uFF1A\u4EE4\u724C/\u5BC6\u7801\u4E0D\u4F1A\u518D\u6B21\u660E\u6587\u663E\u793A\u3002",
11368
+ "WSS \u57DF\u540D\u9700\u5728 Cloudflare \u63A7\u5236\u53F0\u7ED1\u5B9A\u81EA\u5B9A\u4E49\u57DF\u540E\u4F7F\u7528\uFF08*.workers.dev \u56FD\u5185\u4E0D\u53EF\u8FBE\uFF09\u3002",
11369
+ "========================================================"
11370
+ ].join("\n");
11371
+ }
11372
+ var EDGE_RELAY_COMPAT_DATE, DEFAULT_DO_CLASS, D1_READY_TIMEOUT_MS, D1_RETRY_INITIAL_DELAY_MS, D1_RETRY_MAX_DELAY_MS, MONITOR_SETUP_TIMEOUT_MS;
11373
+ var init_deploy2 = __esm({
11374
+ "src/edge/deploy.ts"() {
11375
+ "use strict";
11376
+ init_cf_api();
11377
+ init_edge_relay_schema();
11378
+ EDGE_RELAY_COMPAT_DATE = "2026-01-01";
11379
+ DEFAULT_DO_CLASS = "MeshRoom";
11380
+ D1_READY_TIMEOUT_MS = 9e4;
11381
+ D1_RETRY_INITIAL_DELAY_MS = 500;
11382
+ D1_RETRY_MAX_DELAY_MS = 5e3;
11383
+ MONITOR_SETUP_TIMEOUT_MS = 9e4;
11384
+ }
11385
+ });
11386
+
11387
+ // src/edge/detect.ts
11388
+ function isEdgeRelayBindings(bindings) {
11389
+ const hasToken = bindings.some(
11390
+ (b) => b.name === "MONITOR_TOKEN" && (b.type === "plain_text" || bindingType(b) === "secret_text")
11391
+ );
11392
+ const hasRoom = bindings.some(
11393
+ (b) => b.type === "durable_object_namespace" && (b.name === "MESH_ROOM" || b.class_name === DO_CLASS)
11394
+ ) || bindings.some((b) => b.type === "d1" && b.name === "DB");
11395
+ return hasToken && hasRoom;
11396
+ }
11397
+ function bindingType(b) {
11398
+ return typeof b.type === "string" ? String(b.type) : "";
11399
+ }
11400
+ function readPlainText(bindings, name) {
11401
+ const hit = bindings.find((b) => b.type === "plain_text" && b.name === name);
11402
+ return typeof hit?.text === "string" ? hit.text : "";
11403
+ }
11404
+ function readD1BindingID(bindings) {
11405
+ const hit = bindings.find((b) => b.type === "d1" && b.name === "DB");
11406
+ return typeof hit?.id === "string" ? hit.id : "";
11407
+ }
11408
+ function settingsBindings(settings) {
11409
+ if (!settings || typeof settings !== "object") return [];
11410
+ const raw = settings.bindings;
11411
+ if (!Array.isArray(raw)) return [];
11412
+ return raw.filter((b) => !!b && typeof b === "object" && typeof b.name === "string");
11413
+ }
11414
+ function looksLikeRelayScript(name) {
11415
+ return /(edge[-_]?relay|mobihop|relay)/i.test(name);
11416
+ }
11417
+ function matchZone(domain, zones) {
11418
+ const d = domain.trim().toLowerCase().replace(/\.$/, "");
11419
+ if (!d) return null;
11420
+ let best = null;
11421
+ for (const z of zones) {
11422
+ const name = (z.name || "").trim().toLowerCase().replace(/\.$/, "");
11423
+ if (!name) continue;
11424
+ if (d === name || d.endsWith("." + name)) {
11425
+ if (!best || name.length > best.name.length) best = z;
11426
+ }
11427
+ }
11428
+ return best;
11429
+ }
11430
+ function pickWorkerDomain(domains, workerName) {
11431
+ const hits = domains.filter((d) => d.service === workerName && d.hostname).sort((a, b) => {
11432
+ const ae = a.enabled === false ? 1 : 0;
11433
+ const be = b.enabled === false ? 1 : 0;
11434
+ if (ae !== be) return ae - be;
11435
+ return a.hostname.localeCompare(b.hostname);
11436
+ });
11437
+ return hits[0]?.hostname || "";
11438
+ }
11439
+ function pickDashboardProject(projects, workerName) {
11440
+ const exact = projects.find((p) => p.name === `${workerName}-dashboard`);
11441
+ if (exact) return { project: exact.name, guessed: false };
11442
+ const fuzzy = projects.filter((p) => /(dashboard|monitor)/i.test(p.name || ""));
11443
+ if (fuzzy.length === 1) return { project: fuzzy[0].name, guessed: true };
11444
+ return { project: "", guessed: false };
11445
+ }
11446
+ function rankScriptNames(names, workerName) {
11447
+ const wanted = (workerName || "").trim();
11448
+ return [...names].sort((a, b) => {
11449
+ const score = (n) => {
11450
+ if (wanted && n === wanted) return 0;
11451
+ if (looksLikeRelayScript(n)) return 1;
11452
+ return 2;
11453
+ };
11454
+ const sa = score(a);
11455
+ const sb = score(b);
11456
+ if (sa !== sb) return sa - sb;
11457
+ return a.localeCompare(b);
11458
+ });
11459
+ }
11460
+ async function probeRelay(baseUrl) {
11461
+ const out2 = { reachable: false, dashboardReady: false, passwordSet: false };
11462
+ try {
11463
+ const health = await fetch(`${baseUrl}/health`, { signal: AbortSignal.timeout(6e3) });
11464
+ if (!health.ok) return out2;
11465
+ out2.reachable = true;
11466
+ } catch {
11467
+ return out2;
11468
+ }
11469
+ try {
11470
+ const root = await fetch(`${baseUrl}/`, { signal: AbortSignal.timeout(6e3) });
11471
+ const contentType = root.headers.get("content-type") || "";
11472
+ if (root.ok && /text\/html/i.test(contentType)) {
11473
+ const html = await root.text();
11474
+ out2.dashboardReady = /<!doctype\s+html|<html\b/i.test(html);
11475
+ }
11476
+ } catch {
11477
+ }
11478
+ try {
11479
+ const status2 = await fetch(`${baseUrl}/auth/status`, { signal: AbortSignal.timeout(6e3) });
11480
+ if (status2.ok) {
11481
+ const body = await status2.json();
11482
+ out2.passwordSet = body.setupRequired === false;
11483
+ }
11484
+ } catch {
11485
+ }
11486
+ return out2;
11487
+ }
11488
+ async function detectEdgeRelay(client, opts) {
11489
+ const warnings = [];
11490
+ const accountId = opts.accountId;
11491
+ const probeFn = opts.probeFn ?? probeRelay;
11492
+ const doProbe = opts.probe !== false;
11493
+ let names = [];
11494
+ try {
11495
+ names = await client.listScripts(accountId);
11496
+ } catch (err) {
11497
+ throw new Error(
11498
+ `\u8BFB\u53D6 Worker \u811A\u672C\u5217\u8868\u5931\u8D25\uFF08\u9700\u8981 Workers Scripts / Read \u6743\u9650\uFF09\uFF1A${err instanceof Error ? err.message : String(err)}`
11499
+ );
11500
+ }
11501
+ if (!Array.isArray(names)) names = [];
11502
+ let domains = [];
11503
+ try {
11504
+ domains = await client.listWorkerDomains(accountId);
11505
+ } catch (err) {
11506
+ warnings.push(`\u8BFB\u53D6 Worker \u57DF\u540D\u7ED1\u5B9A\u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}`);
11507
+ }
11508
+ let d1List = [];
11509
+ try {
11510
+ d1List = await client.listD1Databases(accountId);
11511
+ } catch (err) {
11512
+ warnings.push(`\u8BFB\u53D6 D1 \u6570\u636E\u5E93\u5217\u8868\u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}`);
11513
+ }
11514
+ let projects = [];
11515
+ try {
11516
+ projects = await client.listPagesProjects(accountId);
11517
+ } catch (err) {
11518
+ warnings.push(`\u8BFB\u53D6 Pages \u9879\u76EE\u5217\u8868\u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}`);
11519
+ }
11520
+ let zones = [];
11521
+ try {
11522
+ zones = await client.listZones();
11523
+ } catch (err) {
11524
+ warnings.push(`\u8BFB\u53D6 Zone \u5217\u8868\u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}`);
11525
+ }
11526
+ let workersSubdomain = "";
11527
+ try {
11528
+ workersSubdomain = await client.getWorkersSubdomain(accountId);
11529
+ } catch {
11530
+ }
11531
+ const ranked = rankScriptNames(names, opts.workerName || "");
11532
+ const toProbe = ranked.slice(0, MAX_SETTINGS_PROBES);
11533
+ if (ranked.length > toProbe.length) {
11534
+ warnings.push(
11535
+ `\u8D26\u53F7\u4E0B\u6709 ${ranked.length} \u4E2A Worker \u811A\u672C\uFF0C\u53EA\u68C0\u67E5\u4E86\u524D ${toProbe.length} \u4E2A\uFF08\u4F18\u5148\u540D\u5B57\u50CF\u76F2\u4E2D\u7EE7\u7684\uFF09`
11536
+ );
11537
+ }
11538
+ const instances = [];
11539
+ for (const name of toProbe) {
11540
+ let bindings;
11541
+ try {
11542
+ const settings = await client.getScriptSettings(accountId, name);
11543
+ bindings = settingsBindings(settings);
11544
+ } catch {
11545
+ continue;
11546
+ }
11547
+ if (!isEdgeRelayBindings(bindings)) continue;
11548
+ const w = [];
11549
+ const domain = pickWorkerDomain(domains, name);
11550
+ if (!domain) {
11551
+ w.push("\u672A\u7ED1\u5B9A\u81EA\u5B9A\u4E49\u57DF\u540D\uFF1Aworkers.dev \u751F\u4EA7\u94FE\u8DEF\u88AB\u963B\u65AD\uFF0C\u8282\u70B9\u8FDE\u4E0D\u4E0A");
11552
+ }
11553
+ const zone = matchZone(domain, zones);
11554
+ const dash = pickDashboardProject(projects, name);
11555
+ const d1ID = readD1BindingID(bindings);
11556
+ const d1 = d1List.find((db) => db.uuid === d1ID) ?? d1List.find((db) => db.name === `${name}-monitor`);
11557
+ if (!d1) w.push("\u6CA1\u627E\u5230\u76D1\u6D4B\u6570\u636E\u5E93\uFF08D1\uFF09\uFF0C\u76D1\u6D4B\u53F0\u53EF\u80FD\u4E0D\u53EF\u7528");
11558
+ const monitorToken = readPlainText(bindings, "MONITOR_TOKEN");
11559
+ if (!monitorToken) {
11560
+ w.push("\u4E0A\u62A5\u4EE4\u724C\u4EE5 secret \u5B58\u50A8\u6216\u5DF2\u88AB\u79FB\u9664\uFF0C\u65E0\u6CD5\u56DE\u586B \u2014\u2014 \u8BF7\u5230 Worker \u7AEF\u6838\u5BF9 MONITOR_TOKEN");
11561
+ }
11562
+ let workerUrl = domain ? `https://${domain}` : "";
11563
+ if (!workerUrl && workersSubdomain) {
11564
+ workerUrl = `https://${name}.${workersSubdomain}.workers.dev`;
11565
+ }
11566
+ let reachable = false;
11567
+ let dashboardReady = false;
11568
+ let passwordSet = false;
11569
+ if (doProbe && domain) {
11570
+ try {
11571
+ const probe = await probeFn(workerUrl);
11572
+ reachable = probe.reachable;
11573
+ dashboardReady = probe.dashboardReady;
11574
+ passwordSet = probe.passwordSet;
11575
+ if (!reachable) {
11576
+ w.push("\u672C\u673A\u8BBF\u95EE\u4E0D\u5230\u8BE5\u57DF\u540D\uFF08\u53EF\u80FD\u9700\u8981\u4EE3\u7406\uFF09\uFF0C\u914D\u7F6E\u4ECD\u53EF\u56DE\u586B");
11577
+ }
11578
+ if (reachable && !dashboardReady) {
11579
+ w.push("\u76D1\u6D4B\u53F0\u672A\u90E8\u7F72\uFF1A\u76F2\u4E2D\u7EE7\u6839\u8DEF\u5F84\u5C1A\u672A\u8FD4\u56DE\u76D1\u6D4B\u9875\u9762");
11580
+ }
11581
+ } catch (err) {
11582
+ w.push(`\u53EF\u8FBE\u6027\u63A2\u6D4B\u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}`);
11583
+ }
11584
+ }
11585
+ instances.push({
11586
+ workerName: name,
11587
+ domain,
11588
+ workerUrl,
11589
+ wssEndpoint: domain ? `wss://${domain}/mesh/<network_hash>?peer_id=<16hex>` : "",
11590
+ zoneId: zone?.id || "",
11591
+ zoneName: zone?.name || "",
11592
+ dashboardProject: dash.project,
11593
+ dashboardUrl: dashboardReady ? workerUrl : "",
11594
+ dashboardReady,
11595
+ d1Name: d1?.name || "",
11596
+ d1Uuid: d1?.uuid || "",
11597
+ doClass: DO_CLASS,
11598
+ monitorToken,
11599
+ limits: {
11600
+ windowMs: readPlainText(bindings, "WINDOW_MS"),
11601
+ maxBytes: readPlainText(bindings, "MAX_BYTES_PER_WINDOW"),
11602
+ maxPackets: readPlainText(bindings, "MAX_PACKETS_PER_WINDOW"),
11603
+ maxPeers: readPlainText(bindings, "MAX_PEERS_PER_ROOM")
11604
+ },
11605
+ reachable,
11606
+ passwordSet,
11607
+ warnings: w
11608
+ });
11609
+ }
11610
+ const wantedDomain = (opts.domain || "").trim().toLowerCase();
11611
+ const wantedWorker = (opts.workerName || "").trim();
11612
+ let filtered = instances;
11613
+ if (wantedDomain || wantedWorker) {
11614
+ const hit = instances.filter(
11615
+ (i) => wantedDomain && i.domain.toLowerCase() === wantedDomain || wantedWorker && i.workerName === wantedWorker
11616
+ );
11617
+ if (hit.length > 0) filtered = hit;
11618
+ }
11619
+ filtered.sort((a, b) => a.workerName.localeCompare(b.workerName));
11620
+ return { instances: filtered, warnings };
11621
+ }
11622
+ function formatEdgeDetectSummary(result) {
11623
+ const lines = [""];
11624
+ if (result.instances.length === 0) {
11625
+ lines.push("\u6CA1\u6709\u68C0\u6D4B\u5230\u76F2\u4E2D\u7EE7\u5B9E\u4F8B\uFF08\u8BE5\u8D26\u53F7\u4E0B\u6682\u65E0\u5339\u914D\u7684 Worker\uFF09\u3002");
11626
+ lines.push("\u5982\u679C\u662F\u521A\u90E8\u7F72\u4F46\u8FD9\u91CC\u67E5\u4E0D\u5230\uFF1A\u786E\u8BA4 Token \u5177\u5907 Workers Scripts / Read \u6743\u9650\u3002");
11627
+ } else {
11628
+ lines.push(`\u68C0\u6D4B\u5230 ${result.instances.length} \u4E2A\u76F2\u4E2D\u7EE7\u5B9E\u4F8B\uFF1A`);
11629
+ result.instances.forEach((ins, i) => {
11630
+ const token = ins.monitorToken ? `${ins.monitorToken.slice(0, 8)}\u2026\uFF08${ins.monitorToken.length} \u4F4D\uFF09` : "\uFF08\u4E0D\u53EF\u8BFB\u53D6\uFF09";
11631
+ lines.push("");
11632
+ lines.push(`[${i + 1}] ${ins.workerName}`);
11633
+ lines.push(` \u57DF\u540D: ${ins.domain || "\uFF08\u672A\u7ED1\u5B9A\u81EA\u5B9A\u4E49\u57DF\u540D\uFF09"}`);
11634
+ lines.push(` \u76D1\u6D4B API: ${ins.workerUrl || "\uFF08\u672A\u77E5\uFF09"}`);
11635
+ lines.push(` WSS \u7AEF\u70B9: ${ins.wssEndpoint || "\uFF08\u9700\u5148\u7ED1\u5B9A\u57DF\u540D\uFF09"}`);
11636
+ lines.push(` Zone: ${ins.zoneName ? `${ins.zoneName} (${ins.zoneId})` : "\uFF08\u672A\u5339\u914D\uFF09"}`);
11637
+ lines.push(` \u76D1\u6D4B\u53F0: ${ins.dashboardReady ? ins.dashboardUrl : "\u672A\u90E8\u7F72 / \u6839\u8DEF\u5F84\u4E0D\u53EF\u7528"}`);
11638
+ lines.push(` D1: ${ins.d1Name || "\uFF08\u672A\u627E\u5230\uFF09"}`);
11639
+ lines.push(` \u4E0A\u62A5\u4EE4\u724C: ${token}`);
11640
+ lines.push(
11641
+ ` \u53EF\u8FBE\u6027: ${ins.reachable ? "\u53EF\u8FBE" : "\u672C\u673A\u4E0D\u53EF\u8FBE"} \xB7 \u76D1\u6D4B\u53F0\u5BC6\u7801: ${ins.passwordSet ? "\u5DF2\u8BBE\u7F6E" : "\u672A\u8BBE\u7F6E / \u672A\u77E5"}`
11642
+ );
11643
+ for (const w of ins.warnings) lines.push(` \u63D0\u793A: ${w}`);
11644
+ });
11645
+ }
11646
+ if (result.warnings.length > 0) {
11647
+ lines.push("");
11648
+ lines.push("\u5176\u5B83\u63D0\u793A\uFF1A");
11649
+ for (const w of result.warnings) lines.push(` - ${w}`);
11650
+ }
11651
+ lines.push("");
11652
+ lines.push("\u8BF4\u660E\uFF1A\u76D1\u6D4B\u53F0\u5BC6\u7801\u53EA\u4FDD\u5B58\u54C8\u5E0C\uFF0C\u65E0\u6CD5\u8BFB\u53D6\uFF1B\u9700\u8981\u91CD\u7F6E\u8BF7\u91CD\u65B0\u90E8\u7F72\u6216\u5728\u76D1\u6D4B\u53F0\u91CC\u6539\u5BC6\u3002");
11653
+ return lines.join("\n") + "\n";
11654
+ }
11655
+ var DO_CLASS, MAX_SETTINGS_PROBES;
11656
+ var init_detect = __esm({
11657
+ "src/edge/detect.ts"() {
11658
+ "use strict";
11659
+ DO_CLASS = "MeshRoom";
11660
+ MAX_SETTINGS_PROBES = 12;
11661
+ }
11662
+ });
11663
+
11664
+ // src/edge/command.ts
11665
+ var command_exports3 = {};
11666
+ __export(command_exports3, {
11667
+ runEdgeCommand: () => runEdgeCommand
11668
+ });
11669
+ function randomPassword2(bytes = 12) {
11670
+ const arr = new Uint8Array(bytes);
11671
+ crypto.getRandomValues(arr);
11672
+ return Array.from(arr, (b) => b.toString(16).padStart(2, "0")).join("").slice(0, 16);
11673
+ }
11674
+ async function runEdgeCommand(args) {
11675
+ const action = args.positionals[0] ?? (flagBool(args, "h") || flagBool(args, "help") ? "help" : "deploy");
11676
+ if (action === "help" || flagBool(args, "h") || flagBool(args, "help")) {
11677
+ process.stdout.write(EDGE_HELP);
11678
+ return;
11679
+ }
11680
+ if (action === "status") {
11681
+ await runEdgeStatus(args);
11682
+ return;
11683
+ }
11684
+ if (action !== "deploy") {
11685
+ process.stderr.write(`\u672A\u77E5 edge \u52A8\u4F5C\uFF1A${action}
11686
+
11687
+ `);
11688
+ process.stderr.write(EDGE_HELP);
11689
+ process.exitCode = 1;
11690
+ return;
11691
+ }
11692
+ const token = flagString(args, "token") || process.env.CLOUDFLARE_API_TOKEN || "";
11693
+ if (!token) {
11694
+ process.stderr.write("\u7F3A\u5C11 --token \u53C2\u6570\uFF08\u6216\u8BBE\u7F6E CLOUDFLARE_API_TOKEN\uFF09\n");
11695
+ process.exitCode = 1;
11696
+ return;
11697
+ }
11698
+ const domain = flagString(args, "domain").trim();
11699
+ if (!domain) {
11700
+ process.stderr.write("\u7F3A\u5C11 --domain\uFF08\u76F2\u4E2D\u7EE7\u5FC5\u987B\u81EA\u5B9A\u4E49\u57DF\u540D\uFF09\n");
11701
+ process.exitCode = 1;
11702
+ return;
11703
+ }
11704
+ const client = new CloudflareClient({ token });
11705
+ let accountId = flagString(args, "account").trim();
11706
+ if (!accountId) {
11707
+ const accounts = await client.listAccounts();
11708
+ if (accounts.length === 0) {
11709
+ process.stderr.write("\u8D26\u53F7\u5217\u8868\u4E3A\u7A7A\uFF0C\u8BF7\u7528 --account \u6307\u5B9A\n");
11710
+ process.exitCode = 1;
11711
+ return;
11712
+ }
11713
+ const account = accounts[0];
11714
+ accountId = account.id;
11715
+ process.stderr.write(`\u4F7F\u7528\u8D26\u53F7\uFF1A${account.name}\uFF08${accountId.slice(0, 8)}\u2026\uFF09
11716
+ `);
11717
+ }
11718
+ let zoneId = flagString(args, "zone-id").trim();
11719
+ if (!zoneId) {
11720
+ const zones = await client.listZones();
11721
+ const normalizedDomain = domain.toLowerCase().replace(/\.$/, "");
11722
+ const match = zones.filter((z) => normalizedDomain === z.name.toLowerCase() || normalizedDomain.endsWith("." + z.name.toLowerCase())).sort((a, b) => b.name.length - a.name.length)[0];
11723
+ if (match) {
11724
+ zoneId = match.id;
11725
+ process.stderr.write(`\u627E\u5230 zone\uFF1A${match.name}\uFF0C\u5C06\u81EA\u52A8\u7ED1\u5B9A\u57DF\u540D
11726
+ `);
11727
+ } else {
11728
+ process.stderr.write(`\u672A\u627E\u5230\u8986\u76D6 ${domain} \u7684 zone\uFF0C\u8DF3\u8FC7\u81EA\u52A8\u7ED1\u5B9A\uFF1B\u8BF7\u90E8\u7F72\u540E\u5728\u63A7\u5236\u53F0\u624B\u52A8\u7ED1\u5B9A ${domain}
11729
+ `);
11730
+ }
11731
+ }
11732
+ let password = flagString(args, "monitor-password").trim();
11733
+ let generatedPw = false;
11734
+ if (!password) {
11735
+ password = randomPassword2();
11736
+ generatedPw = true;
11737
+ }
11738
+ if (password.length < 8) {
11739
+ process.stderr.write("\u76D1\u6D4B\u53F0\u5BC6\u7801\u81F3\u5C11 8 \u4F4D\n");
11740
+ process.exitCode = 1;
11741
+ return;
11742
+ }
11743
+ const result = await deployEdgeRelay(client, {
11744
+ accountId,
11745
+ domain,
11746
+ workerName: flagString(args, "worker-name").trim() || void 0,
11747
+ monitorPassword: password,
11748
+ monitorToken: flagString(args, "monitor-token").trim() || void 0,
11749
+ dashboardProject: flagString(args, "dashboard-project").trim() || void 0,
11750
+ withDashboard: !flagBool(args, "no-dashboard"),
11751
+ zoneId: zoneId || void 0,
11752
+ limits: {
11753
+ windowMs: flagNumber(args, "window-ms", 1e3).toString(),
11754
+ maxBytesPerWindow: flagNumber(args, "max-bytes", 1048576).toString(),
11755
+ maxPacketsPerWindow: flagNumber(args, "max-packets", 2e3).toString(),
11756
+ maxPeersPerRoom: flagNumber(args, "max-peers", 512).toString()
11757
+ },
11758
+ onProgress: (m) => process.stdout.write(`[edge] ${m}
11759
+ `)
11760
+ });
11761
+ process.stdout.write(formatEdgeDeploySummary(result));
11762
+ if (generatedPw) {
11763
+ process.stdout.write("\uFF08\u76D1\u6D4B\u53F0\u5BC6\u7801\u4E3A\u81EA\u52A8\u751F\u6210\uFF0C\u4E0A\u65B9\u5DF2\u663E\u793A\uFF0C\u8BF7\u7ACB\u5373\u4FDD\u5B58\uFF09\n");
11764
+ }
11765
+ }
11766
+ async function runEdgeStatus(args) {
11767
+ const token = flagString(args, "token") || process.env.CLOUDFLARE_API_TOKEN || "";
11768
+ if (!token) {
11769
+ process.stderr.write("\u7F3A\u5C11 --token \u53C2\u6570\uFF08\u6216\u8BBE\u7F6E CLOUDFLARE_API_TOKEN\uFF09\n");
11770
+ process.exitCode = 1;
11771
+ return;
11772
+ }
11773
+ const client = new CloudflareClient({ token });
11774
+ let accountId = flagString(args, "account").trim();
11775
+ if (!accountId) {
11776
+ const accounts = await client.listAccounts();
11777
+ if (accounts.length === 0) {
11778
+ process.stderr.write("\u8D26\u53F7\u5217\u8868\u4E3A\u7A7A\uFF0C\u8BF7\u7528 --account \u6307\u5B9A\n");
11779
+ process.exitCode = 1;
11780
+ return;
11781
+ }
11782
+ accountId = accounts[0].id;
11783
+ process.stderr.write(`\u4F7F\u7528\u8D26\u53F7\uFF1A${accounts[0].name}\uFF08${accountId.slice(0, 8)}\u2026\uFF09
11784
+ `);
11785
+ }
11786
+ const result = await detectEdgeRelay(client, {
11787
+ accountId,
11788
+ domain: flagString(args, "domain").trim() || void 0,
11789
+ workerName: flagString(args, "worker-name").trim() || void 0,
11790
+ probe: !flagBool(args, "no-probe")
11791
+ });
11792
+ if (flagBool(args, "json")) {
11793
+ process.stdout.write(JSON.stringify({ ok: true, accountId, ...result }, null, 2) + "\n");
11794
+ return;
11795
+ }
11796
+ process.stdout.write(formatEdgeDetectSummary(result));
11797
+ }
11798
+ var EDGE_HELP;
11799
+ var init_command3 = __esm({
11800
+ "src/edge/command.ts"() {
11801
+ "use strict";
11802
+ init_args();
11803
+ init_cf_api();
11804
+ init_deploy2();
11805
+ init_detect();
11806
+ EDGE_HELP = `
11807
+ cfpilot edge \u2014\u2014 \u76F2\u4E2D\u7EE7 / \u4E91\u76D1\u6D4B\u53F0\u90E8\u7F72\uFF08MobiHop \u8FB9\u7F18\u5DE5\u7A0B\uFF09
11808
+
11809
+ \u7528\u6CD5:
11810
+ cfpilot edge deploy [\u9009\u9879] \u90E8\u7F72\u76F2\u4E2D\u7EE7 Worker + \u76D1\u6D4B\u9762\u677F
11811
+ cfpilot edge status [\u9009\u9879] \u68C0\u6D4B\u5DF2\u90E8\u7F72\u7684\u76F2\u4E2D\u7EE7\u5B9E\u4F8B\uFF08\u53EA\u8BFB\uFF0C\u7EDD\u4E0D\u90E8\u7F72\uFF09
11812
+ cfpilot edge help \u663E\u793A\u672C\u5E2E\u52A9
11813
+
11814
+ status \u9009\u9879:
11815
+ --token <token> Cloudflare API Token\uFF08\u6216 CLOUDFLARE_API_TOKEN\uFF09
11816
+ --account <id> \u76EE\u6807\u8D26\u53F7 ID\uFF08\u4E0D\u4F20\u5219\u53D6\u8D26\u53F7\u5217\u8868\u7B2C\u4E00\u4E2A\uFF09
11817
+ --domain <host> \u53EA\u770B\u8FD9\u4E2A\u57DF\u540D\u5BF9\u5E94\u7684\u5B9E\u4F8B
11818
+ --worker-name <name> \u53EA\u770B\u8FD9\u4E2A Worker
11819
+ --no-probe \u8DF3\u8FC7\u57DF\u540D\u53EF\u8FBE\u6027\u63A2\u6D4B\uFF08\u79BB\u7EBF\u6392\u67E5\u65F6\u7528\uFF09
11820
+ --json \u4EE5 JSON \u8F93\u51FA\uFF08\u5199\u811A\u672C\u7528\uFF09
11821
+
11822
+ deploy \u9009\u9879:
11823
+ --token <token> Cloudflare API Token\uFF08\u6216 CLOUDFLARE_API_TOKEN\uFF09
11824
+ --account <id> \u76EE\u6807\u8D26\u53F7 ID\uFF08\u4E0D\u4F20\u5219\u53D6\u8D26\u53F7\u5217\u8868\u7B2C\u4E00\u4E2A\uFF09
11825
+ --domain <host> \u76F2\u4E2D\u7EE7\u81EA\u5B9A\u4E49\u57DF\u540D\uFF08\u5FC5\u586B\uFF1B*.workers.dev \u56FD\u5185\u88AB\u6C61\u67D3\uFF09
11826
+ --worker-name <name> Worker \u540D\uFF08\u9ED8\u8BA4 mobihop-edge-relay\uFF09
11827
+ --monitor-password <pw> \u76D1\u6D4B\u53F0\u521D\u59CB\u5BC6\u7801\uFF08\u22658 \u4F4D\uFF1B\u7559\u7A7A\u5219\u968F\u673A\u751F\u6210\uFF09
11828
+ --monitor-token <t> \u4E0A\u62A5\u4EE4\u724C\uFF08\u7559\u7A7A\u5219\u968F\u673A\u751F\u6210\uFF09
11829
+ --dashboard-project <n> \u76D1\u6D4B\u9762\u677F Pages \u9879\u76EE\u540D\uFF08\u9ED8\u8BA4 <worker-name>-dashboard\uFF09
11830
+ --no-dashboard \u53EA\u90E8\u7F72 Worker\uFF0C\u4E0D\u90E8\u7F72\u76D1\u6D4B\u9762\u677F
11831
+ --zone-id <id> \u7ED1\u5B9A\u81EA\u5B9A\u4E49\u57DF\u540D\u6240\u9700 zone ID\uFF08\u4E0D\u4F20\u5219\u6309\u57DF\u540D\u4E3B\u57DF\u67E5\uFF1B\u67E5\u4E0D\u5230\u4F1A\u63D0\u793A\u624B\u7ED1\uFF09
11832
+ --window-ms <n> \u6ED1\u52A8\u7A97\u53E3 ms\uFF08\u9ED8\u8BA4 1000\uFF09
11833
+ --max-bytes <n> \u7A97\u53E3\u5B57\u8282\u4E0A\u9650\uFF08\u9ED8\u8BA4 1048576\uFF09
11834
+ --max-packets <n> \u7A97\u53E3\u5305\u6570\u4E0A\u9650\uFF08\u9ED8\u8BA4 2000\uFF09
11835
+ --max-peers <n> \u5355\u623F\u95F4\u8FDE\u63A5\u4E0A\u9650\uFF08\u9ED8\u8BA4 512\uFF09
11836
+
11837
+ Token \u6743\u9650\uFF08\u65B0\u589E\uFF0C\u57FA\u7840\u4EE3\u7406\u90E8\u7F72\u4E0D\u9700\u8981\uFF09:
11838
+ Workers Scripts / Edit \xB7 Durable Objects / Edit \xB7 D1 / Edit \xB7 Pages / Edit
11839
+ Zone & DNS / Edit\uFF08\u7ED1\u5B9A\u81EA\u5B9A\u4E49\u57DF\u65F6\u9700\u8981\uFF09
11840
+
11841
+ \u793A\u4F8B:
11842
+ cfpilot edge deploy --token <TOKEN> --domain relay.example.com --monitor-password <PW>
11843
+ `;
11844
+ }
11845
+ });
11846
+
11847
+ // src/mesh/command.ts
11848
+ var command_exports4 = {};
11849
+ __export(command_exports4, {
11850
+ runMeshCommand: () => runMeshCommand
11851
+ });
11852
+ async function runMeshCommand(args) {
11853
+ const raw = (args.positionals[0] ?? "help").toLowerCase();
11854
+ if (flagBool(args, "h") || flagBool(args, "help") || raw === "help") {
11855
+ process.stdout.write(MESH_HELP);
11856
+ return;
11857
+ }
11858
+ if (!SUBCOMMANDS.includes(raw)) {
11859
+ process.stderr.write(`\u672A\u77E5 mesh \u52A8\u4F5C\uFF1A${raw}
11860
+
11861
+ ${MESH_HELP}`);
11862
+ process.exitCode = 1;
11863
+ return;
11864
+ }
11865
+ const sub = raw;
11866
+ if (sub === "join" && !(args.positionals[1] ?? "").trim()) {
11867
+ process.stderr.write("mesh join \u9700\u8981 <uri> \u53C2\u6570\uFF08mobihop://join/v1/...\uFF09\n");
11868
+ process.exitCode = 1;
11869
+ return;
11870
+ }
11871
+ process.stdout.write(`[mesh:${sub}] ${PHASE_3B_NOTICE}
11872
+ `);
11873
+ }
11874
+ var MESH_HELP, SUBCOMMANDS, PHASE_3B_NOTICE;
11875
+ var init_command4 = __esm({
11876
+ "src/mesh/command.ts"() {
11877
+ "use strict";
11878
+ init_args();
11879
+ MESH_HELP = `
11880
+ cfpilot mesh \u2014\u2014 MobiHop \u7EC4\u7F51\uFF08CFPilot +mesh \u53D8\u4F53\uFF0C\u9AA8\u67B6\u9636\u6BB5\uFF09
11881
+
11882
+ \u26A0\uFE0F \u5F53\u524D\u7248\u672C\u4E3A\u5DE5\u7A0B\u9AA8\u67B6\uFF1A\u547D\u4EE4\u6846\u67B6\u5DF2\u5C31\u4F4D\uFF0C\u7EC4\u7F51\u534F\u8BAE\u5B9E\u73B0\u5F85 Phase 3b \u5B8C\u6210\u3002
11883
+ \u5C4A\u65F6\u672C\u547D\u4EE4\u5C06\u4E0E MobiHop \u8282\u70B9\u5B57\u8282\u7EA7\u4E92\u901A\uFF0832B \u5E27 / Noise IKpsk2 / AEAD / \u6253\u6D1E / \u9009\u8DEF\uFF09\u3002
11884
+
11885
+ \u7528\u6CD5:
11886
+ cfpilot mesh help \u663E\u793A\u672C\u5E2E\u52A9
11887
+ cfpilot mesh status \u67E5\u770B\u7EC4\u7F51\u72B6\u6001\uFF08\u5F85 3b\uFF09
11888
+ cfpilot mesh peers \u67E5\u770B\u5BF9\u7B49\u8282\u70B9\uFF08\u5F85 3b\uFF09
11889
+ cfpilot mesh up \u542F\u52A8\u7EC4\u7F51\uFF08\u9700\u7BA1\u7406\u5458/root\uFF1B\u5F85 3b\uFF09
11890
+ cfpilot mesh down \u505C\u6B62\u7EC4\u7F51\uFF08\u5F85 3b\uFF09
11891
+ cfpilot mesh invite \u751F\u6210\u5165\u7F51\u9080\u8BF7\uFF08\u5F85 3b\uFF09
11892
+ cfpilot mesh join <uri> \u52A0\u5165\u7F51\u7EDC\uFF08\u5F85 3b\uFF09
11893
+
11894
+ TUN \u865A\u62DF\u7F51\u5361\u9700\u8981\u7BA1\u7406\u5458/root \u6743\u9650\uFF1B\u65E5\u5E38\u4F7F\u7528\u5EFA\u8BAE\u684C\u9762\u7248 +mesh \u53D8\u4F53\uFF08\u56FE\u5F62\u5F15\u5BFC\u63D0\u6743\uFF09\u3002
11895
+ \u534F\u8BAE\u6743\u5A01\uFF1AE:\\Projects\\MobiHop\uFF08docs/MESH_INTEGRATION_CONTRACT.md\uFF09\u3002
11896
+ `;
11897
+ SUBCOMMANDS = ["help", "status", "peers", "up", "down", "invite", "join"];
11898
+ PHASE_3B_NOTICE = "mesh \u547D\u4EE4\u5904\u4E8E Phase 3a \u9AA8\u67B6\u9636\u6BB5\uFF1A\u534F\u8BAE\u5B9E\u73B0\uFF08\u542B\u4E0E MobiHop \u8282\u70B9\u4E92\u901A\uFF09\u5F85 Phase 3b \u5B8C\u6210\u3002\u5F53\u524D\u4EC5\u9A8C\u8BC1\u547D\u4EE4\u5206\u53D1\u4E0E\u53C2\u6570\u6821\u9A8C\u3002";
11899
+ }
11900
+ });
11901
+
10926
11902
  // src/sources/builtin.generated.ts
10927
11903
  var BUILTIN_SOURCES_JSON;
10928
11904
  var init_builtin_generated = __esm({
@@ -10936,7 +11912,7 @@ var init_builtin_generated = __esm({
10936
11912
  import {
10937
11913
  existsSync as existsSync3,
10938
11914
  mkdirSync as mkdirSync3,
10939
- readFileSync as readFileSync6,
11915
+ readFileSync as readFileSync7,
10940
11916
  renameSync as renameSync2,
10941
11917
  unlinkSync as unlinkSync2,
10942
11918
  writeFileSync as writeFileSync4
@@ -10959,7 +11935,7 @@ function blankSources() {
10959
11935
  }
10960
11936
  function readSourcesRaw() {
10961
11937
  try {
10962
- return readFileSync6(sourcesPath(), "utf8");
11938
+ return readFileSync7(sourcesPath(), "utf8");
10963
11939
  } catch {
10964
11940
  return "";
10965
11941
  }
@@ -11588,7 +12564,7 @@ async function syncSources(options = {}) {
11588
12564
  const spec = PROVIDERS[source.type];
11589
12565
  if (spec && lastType === source.type) {
11590
12566
  const wait = spec.minIntervalMs - (Date.now() - lastAt);
11591
- if (wait > 0) await new Promise((resolve4) => setTimeout(resolve4, wait));
12567
+ if (wait > 0) await new Promise((resolve5) => setTimeout(resolve5, wait));
11592
12568
  }
11593
12569
  lastType = source.type;
11594
12570
  lastAt = Date.now();
@@ -11762,14 +12738,14 @@ __export(light_exports, {
11762
12738
  });
11763
12739
  import { Socket as Socket3 } from "node:net";
11764
12740
  function tcpProbeOnce(ip, port, timeoutMs) {
11765
- return new Promise((resolve4) => {
12741
+ return new Promise((resolve5) => {
11766
12742
  const socket = new Socket3();
11767
12743
  let settled = false;
11768
12744
  const done = (ok) => {
11769
12745
  if (settled) return;
11770
12746
  settled = true;
11771
12747
  socket.destroy();
11772
- resolve4(ok);
12748
+ resolve5(ok);
11773
12749
  };
11774
12750
  socket.setTimeout(timeoutMs, () => done(false));
11775
12751
  socket.once("error", () => done(false));
@@ -11854,8 +12830,8 @@ var init_light = __esm({
11854
12830
  });
11855
12831
 
11856
12832
  // src/sources/command.ts
11857
- var command_exports3 = {};
11858
- __export(command_exports3, {
12833
+ var command_exports5 = {};
12834
+ __export(command_exports5, {
11859
12835
  runSourceCommand: () => runSourceCommand
11860
12836
  });
11861
12837
  function out(text2) {
@@ -12044,7 +13020,7 @@ ${HELP}`);
12044
13020
  }
12045
13021
  }
12046
13022
  var HELP;
12047
- var init_command3 = __esm({
13023
+ var init_command5 = __esm({
12048
13024
  "src/sources/command.ts"() {
12049
13025
  "use strict";
12050
13026
  init_args();
@@ -12095,7 +13071,7 @@ cfpilot source <\u52A8\u4F5C> [\u9009\u9879] \u5916\u90E8 IP \u6570\u636E\u
12095
13071
  // src/scan/single.ts
12096
13072
  import * as net6 from "node:net";
12097
13073
  function probeTcp(ip, port, timeoutMs) {
12098
- return new Promise((resolve4) => {
13074
+ return new Promise((resolve5) => {
12099
13075
  const started = Date.now();
12100
13076
  let settled = false;
12101
13077
  const finish = (result) => {
@@ -12105,7 +13081,7 @@ function probeTcp(ip, port, timeoutMs) {
12105
13081
  socket.destroy();
12106
13082
  } catch {
12107
13083
  }
12108
- resolve4({ stage: "TCP \u5EFA\u8FDE", ms: Date.now() - started, ...result });
13084
+ resolve5({ stage: "TCP \u5EFA\u8FDE", ms: Date.now() - started, ...result });
12109
13085
  };
12110
13086
  const socket = net6.connect({ host: ip, port });
12111
13087
  socket.setTimeout(timeoutMs, () => finish({ ok: false, error: "\u8D85\u65F6" }));
@@ -12380,7 +13356,7 @@ function validateIdentityResponse(value, now) {
12380
13356
  };
12381
13357
  }
12382
13358
  function readExactly(socket, length) {
12383
- return new Promise((resolve4, reject) => {
13359
+ return new Promise((resolve5, reject) => {
12384
13360
  let data = Buffer.alloc(0);
12385
13361
  const cleanup = () => {
12386
13362
  socket.off("data", onData);
@@ -12401,7 +13377,7 @@ function readExactly(socket, length) {
12401
13377
  socket.pause();
12402
13378
  cleanup();
12403
13379
  if (data.length > length) socket.unshift(data.subarray(length));
12404
- resolve4(data.subarray(0, length));
13380
+ resolve5(data.subarray(0, length));
12405
13381
  };
12406
13382
  socket.on("data", onData);
12407
13383
  socket.once("error", onError);
@@ -12473,7 +13449,7 @@ function identifyEgress(options) {
12473
13449
  } catch {
12474
13450
  return Promise.resolve(fail2("config", "\u8BC6\u522B\u914D\u7F6E\u65E0\u6548\uFF1A\u9700\u8981 HTTPS\u3001\u6709\u6548\u77ED\u671F\u4EE4\u724C\u548C\u53EF\u9009 SOCKS5 \u5730\u5740"));
12475
13451
  }
12476
- return new Promise((resolve4) => {
13452
+ return new Promise((resolve5) => {
12477
13453
  let settled = false;
12478
13454
  let request3;
12479
13455
  let socket;
@@ -12485,7 +13461,7 @@ function identifyEgress(options) {
12485
13461
  request3?.destroy();
12486
13462
  socket?.destroy();
12487
13463
  agent.destroy();
12488
- resolve4(result);
13464
+ resolve5(result);
12489
13465
  };
12490
13466
  const timer = setTimeout(() => finish(fail2("timeout", "\u51FA\u53E3\u8BC6\u522B\u8D85\u8FC7\u603B\u8D85\u65F6\u9884\u7B97")), timeoutMs);
12491
13467
  if (proxy) {
@@ -12671,7 +13647,7 @@ function probeWebsite(target, options = {}) {
12671
13647
  } catch {
12672
13648
  return Promise.resolve({ ...base, error: "\u7F51\u7AD9\u68C0\u6D4B\u914D\u7F6E\u65E0\u6548" });
12673
13649
  }
12674
- return new Promise((resolve4) => {
13650
+ return new Promise((resolve5) => {
12675
13651
  let settled = false;
12676
13652
  let socket;
12677
13653
  let request3;
@@ -12683,7 +13659,7 @@ function probeWebsite(target, options = {}) {
12683
13659
  request3?.destroy();
12684
13660
  socket?.destroy();
12685
13661
  agent.destroy();
12686
- resolve4({ ...base, ...patch, ms: Date.now() - started });
13662
+ resolve5({ ...base, ...patch, ms: Date.now() - started });
12687
13663
  };
12688
13664
  const onError = (error) => finish({ status: tlsFailure(error) ? "tls_error" : "http_error", error: tlsFailure(error) ? "\u7F51\u7AD9 TLS \u6821\u9A8C\u5931\u8D25" : "\u6307\u5B9A\u8DEF\u5F84\u8FDE\u63A5\u5931\u8D25" });
12689
13665
  const timer = setTimeout(() => finish({ status: "timeout", error: "\u7F51\u7AD9\u68C0\u6D4B\u8D85\u8FC7\u603B\u8D85\u65F6\u9884\u7B97" }), timeout);
@@ -12909,22 +13885,22 @@ var init_token_command = __esm({
12909
13885
  });
12910
13886
 
12911
13887
  // src/vps/command.ts
12912
- var command_exports4 = {};
12913
- __export(command_exports4, {
13888
+ var command_exports6 = {};
13889
+ __export(command_exports6, {
12914
13890
  runVpsCommand: () => runVpsCommand
12915
13891
  });
12916
13892
  import { spawn } from "node:child_process";
12917
- import { existsSync as existsSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
12918
- import { dirname as dirname4, resolve as resolve3 } from "node:path";
13893
+ import { existsSync as existsSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
13894
+ import { dirname as dirname4, resolve as resolve4 } from "node:path";
12919
13895
  import { fileURLToPath as fileURLToPath3 } from "node:url";
12920
13896
  function loadScript() {
12921
13897
  const here = dirname4(fileURLToPath3(import.meta.url));
12922
13898
  const candidates = [
12923
- resolve3(here, "../assets/vps-socks5.sh"),
12924
- resolve3(here, "../../assets/vps-socks5.sh")
13899
+ resolve4(here, "../assets/vps-socks5.sh"),
13900
+ resolve4(here, "../../assets/vps-socks5.sh")
12925
13901
  ];
12926
13902
  for (const path of candidates) {
12927
- if (existsSync4(path)) return readFileSync7(path, "utf8");
13903
+ if (existsSync4(path)) return readFileSync8(path, "utf8");
12928
13904
  }
12929
13905
  throw new Error("\u5185\u7F6E\u811A\u672C\u7F3A\u5931\uFF08assets/vps-socks5.sh\uFF09\uFF0C\u8BF7\u91CD\u65B0\u5B89\u88C5\u6216\u5347\u7EA7 cfpilot");
12930
13906
  }
@@ -12980,7 +13956,7 @@ async function runVpsCommand(args) {
12980
13956
  }
12981
13957
  return;
12982
13958
  }
12983
- const out2 = resolve3(process.cwd(), flagString(args, "out") ?? "cfpilot-vps-socks5.sh");
13959
+ const out2 = resolve4(process.cwd(), flagString(args, "out") ?? "cfpilot-vps-socks5.sh");
12984
13960
  writeFileSync5(out2, script, { mode: 493 });
12985
13961
  process.stdout.write(
12986
13962
  `
@@ -13004,7 +13980,7 @@ async function runVpsCommand(args) {
13004
13980
  );
13005
13981
  }
13006
13982
  var HELP5;
13007
- var init_command4 = __esm({
13983
+ var init_command6 = __esm({
13008
13984
  "src/vps/command.ts"() {
13009
13985
  "use strict";
13010
13986
  init_args();
@@ -13049,7 +14025,9 @@ Cloudflare Pages \u4EE3\u7406\u90E8\u7F72\u4E0E\u4F18\u9009\u5DE5\u5177
13049
14025
 
13050
14026
  \u7528\u6CD5:
13051
14027
  ${NAME} \u4EA4\u4E92\u83DC\u5355\uFF08\u63A8\u8350\u9996\u6B21\u4F7F\u7528\uFF09
13052
- ${NAME} deploy [\u9009\u9879] \u90E8\u7F72 Pages \u53CC\u9879\u76EE
14028
+ ${NAME} deploy [\u9009\u9879] \u90E8\u7F72 Pages \u53CC\u9879\u76EE\uFF08CFPilot \u4EE3\u7406\u5B9E\u4F8B\uFF09
14029
+ ${NAME} edge <\u52A8\u4F5C> [\u9009\u9879] \u90E8\u7F72\u76F2\u4E2D\u7EE7 / \u4E91\u76D1\u6D4B\u53F0\uFF08MobiHop \u8FB9\u7F18\u5DE5\u7A0B\uFF09
14030
+ ${NAME} mesh <\u52A8\u4F5C> \u7EC4\u7F51\uFF08+mesh \u53D8\u4F53\uFF1B\u5F53\u524D\u9AA8\u67B6\uFF0C\u534F\u8BAE\u5F85 3b\uFF09
13053
14031
  ${NAME} scan [\u9009\u9879] \u672C\u5730\u771F\u8FDE\u63A5\u4F18\u9009
13054
14032
  ${NAME} source <\u52A8\u4F5C> \u5916\u90E8 IP \u6570\u636E\u6E90\u4E0E\u672C\u5730\u5019\u9009\u6C60\u7BA1\u7406
13055
14033
  ${NAME} test [\u9009\u9879] \u6D4B\u8BD5\u5355\u4E2A IP \u7684\u5B8C\u6574\u94FE\u8DEF
@@ -13100,13 +14078,23 @@ async function main() {
13100
14078
  await runDeployCommand2(args);
13101
14079
  return;
13102
14080
  }
14081
+ case "edge": {
14082
+ const { runEdgeCommand: runEdgeCommand2 } = await Promise.resolve().then(() => (init_command3(), command_exports3));
14083
+ await runEdgeCommand2(args);
14084
+ return;
14085
+ }
14086
+ case "mesh": {
14087
+ const { runMeshCommand: runMeshCommand2 } = await Promise.resolve().then(() => (init_command4(), command_exports4));
14088
+ await runMeshCommand2(args);
14089
+ return;
14090
+ }
13103
14091
  case "scan": {
13104
14092
  const { runScanCommand: runScanCommand2 } = await Promise.resolve().then(() => (init_command2(), command_exports2));
13105
14093
  await runScanCommand2(args);
13106
14094
  return;
13107
14095
  }
13108
14096
  case "source": {
13109
- const { runSourceCommand: runSourceCommand2 } = await Promise.resolve().then(() => (init_command3(), command_exports3));
14097
+ const { runSourceCommand: runSourceCommand2 } = await Promise.resolve().then(() => (init_command5(), command_exports5));
13110
14098
  await runSourceCommand2(args);
13111
14099
  return;
13112
14100
  }
@@ -13141,7 +14129,7 @@ async function main() {
13141
14129
  return;
13142
14130
  }
13143
14131
  case "vps": {
13144
- const { runVpsCommand: runVpsCommand2 } = await Promise.resolve().then(() => (init_command4(), command_exports4));
14132
+ const { runVpsCommand: runVpsCommand2 } = await Promise.resolve().then(() => (init_command6(), command_exports6));
13145
14133
  await runVpsCommand2(args);
13146
14134
  return;
13147
14135
  }