dsh-mobile-ios 0.2.9 → 0.2.10
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/lib/client.js +98 -21
- package/package.json +53 -53
- package/src/cloudflare.mjs +52 -7
- package/src/dns-probe.mjs +24 -4
- package/src/provision-local.mjs +107 -8
- package/src/rest.mjs +3 -0
- package/src/zone-health.mjs +251 -0
package/lib/client.js
CHANGED
|
@@ -469,6 +469,9 @@ window.__ModuleLoader__.load({
|
|
|
469
469
|
// 「域名未生效」必须单列:地址开出来了但公网解析不到,显示「已开通」会误导人去扫码。
|
|
470
470
|
const tunnel = ok ? summary.tunnel : null;
|
|
471
471
|
const dnsBroken = tunnel && tunnel.dnsOk === false;
|
|
472
|
+
// 解析失败已经归因到 zone 层时,别再用「解析异常」这种症状词:
|
|
473
|
+
// moved 是归属冲突(改 NS 或换账号才能解),重探一万次也不会变。
|
|
474
|
+
const zoneCode = tunnel?.zone?.code || null;
|
|
472
475
|
// 「进程在跑」与「地址可用」是两件事:域名没生效时隧道进程可能已经起来了,
|
|
473
476
|
// 但扫码必然连不上,所以 running 仍然要求 dnsOk 不为 false。
|
|
474
477
|
const processUp = !!(tunnel && tunnel.state === 'running');
|
|
@@ -478,7 +481,9 @@ window.__ModuleLoader__.load({
|
|
|
478
481
|
remoteState.textContent = !tunnel
|
|
479
482
|
? '—'
|
|
480
483
|
: dnsBroken
|
|
481
|
-
? (
|
|
484
|
+
? (zoneCode === 'moved'
|
|
485
|
+
? '域名归属冲突'
|
|
486
|
+
: processUp ? '已开启 · 域名未生效' : '解析异常 · 未开启')
|
|
482
487
|
: running
|
|
483
488
|
? '已开启'
|
|
484
489
|
: tunnel.provisioned && tunnel.fixedUrl
|
|
@@ -506,7 +511,7 @@ window.__ModuleLoader__.load({
|
|
|
506
511
|
mainBtn.textContent = needsInstall && tunnel.canAutoInstall
|
|
507
512
|
? '安装 cloudflared 并开启远程'
|
|
508
513
|
: dnsBroken
|
|
509
|
-
? '重新检测域名解析'
|
|
514
|
+
? (zoneCode === 'moved' ? '查看原因(域名被占用)' : '重新检测域名解析')
|
|
510
515
|
: running
|
|
511
516
|
? (bannerBusy.remote ? '生成中…' : '生成配对码(远程)')
|
|
512
517
|
: tunnel.mode === 'named'
|
|
@@ -1240,32 +1245,97 @@ window.__ModuleLoader__.load({
|
|
|
1240
1245
|
*/
|
|
1241
1246
|
function showDnsHelpModal(res = {}) {
|
|
1242
1247
|
const ns = Array.isArray(res.publicNs) ? res.publicNs : [];
|
|
1248
|
+
const zone = res.zone && typeof res.zone === 'object' ? res.zone : null;
|
|
1249
|
+
const expectedNs = Array.isArray(zone?.expectedNs) ? zone.expectedNs : [];
|
|
1243
1250
|
const host = stripUrl(summary?.tunnel?.fixedUrl || summary?.tunnel?.hostname || '');
|
|
1244
1251
|
const tampered = Boolean(res.tampered);
|
|
1245
|
-
|
|
1246
|
-
|
|
1247
|
-
|
|
1248
|
-
|
|
1249
|
-
|
|
1252
|
+
// 归因码决定「修法」:moved(域名被另一个账号接管)/ pending(NS 没指过来)/
|
|
1253
|
+
// ns-mismatch(NS 与账号不匹配)/ unresolved(已生效但还没查到)绝不共用一套话术。
|
|
1254
|
+
const code = tampered ? 'tampered' : (zone?.code || 'unknown');
|
|
1255
|
+
const nsLine = expectedNs.length ? { label: '本账号 NS', value: expectedNs.join(' / ') } : null;
|
|
1256
|
+
const accountLine = zone?.accountName ? { label: '本账号', value: zone.accountName } : null;
|
|
1257
|
+
|
|
1258
|
+
const bodies = {
|
|
1259
|
+
tampered: {
|
|
1260
|
+
title: '固定域名被改指',
|
|
1261
|
+
banner: '⚠️ CNAME 已不指向本机隧道',
|
|
1262
|
+
note: '这条 CNAME 现在指向别处,扫码会把指令发给未知服务器,网关已拒绝下发该地址。',
|
|
1263
|
+
steps: [
|
|
1264
|
+
'到 Cloudflare 该域名的 DNS 页面,检查上面这条 CNAME 指向哪里。',
|
|
1265
|
+
'把它改回本机隧道(或直接删除这条记录)。',
|
|
1266
|
+
'回到面板点「重新检测」,通过后重新生成配对码。',
|
|
1267
|
+
],
|
|
1268
|
+
},
|
|
1269
|
+
moved: {
|
|
1270
|
+
title: '域名已被另一个账号接管',
|
|
1271
|
+
banner: '⚠️ 这个域名不再归本机登录的 Cloudflare 账号',
|
|
1272
|
+
note: 'Cloudflare 把这个域名判成了「已迁移(zone moved)」:公网解析走的是另一个 Cloudflare 账号的那份 zone。'
|
|
1273
|
+
+ '本机写进自己账号的记录一条都不会下发,所以地址永远解析不到——重装插件、重开隧道都没用。',
|
|
1274
|
+
steps: [
|
|
1275
|
+
'先确认两台电脑登录的是不是同一个 Cloudflare 账号:每台都跑一次 cloudflared tunnel login,选到不同账号就会形成「同一域名两份 zone、互相抢」。',
|
|
1276
|
+
expectedNs.length
|
|
1277
|
+
? `在域名注册商处把 NS 改回本账号这一对:${expectedNs.join(' / ')}(当前公网是 ${ns.join(' / ') || '未知'})。隧道与 DNS 记录都在这边,改回即全部恢复。`
|
|
1278
|
+
: '在域名注册商处把 NS 改回本机这个账号分配的一对(Cloudflare 后台该域名页可查)。',
|
|
1279
|
+
'若决定改用现在接管的那份 zone:在那台设备上用对应账号重新授权并重新「开启远程」,本机会重建隧道与新地址。',
|
|
1280
|
+
'两种做法都只能二选一,别在两边同时改;改完等几分钟回到面板点「重新检测」。',
|
|
1281
|
+
],
|
|
1282
|
+
},
|
|
1283
|
+
pending: {
|
|
1284
|
+
title: '域名在本账号未生效',
|
|
1285
|
+
banner: '⚠️ 公网 NS 还没指向本账号',
|
|
1286
|
+
note: '域名已经加进本账号,但注册商处的 NS 还没指向本账号分配的那一对,Cloudflare 因此不下发这里的记录。',
|
|
1287
|
+
steps: [
|
|
1288
|
+
expectedNs.length
|
|
1289
|
+
? `到域名注册商把 NS 改成:${expectedNs.join(' / ')}(当前公网是 ${ns.join(' / ') || '未知'})。`
|
|
1290
|
+
: '到域名注册商把 NS 改成 Cloudflare 给本账号分配的那一对(后台域名页可查)。',
|
|
1291
|
+
'若域名其实已在另一个 Cloudflare 账号里生效,先在那个账号删掉它,否则两边会一直互抢。',
|
|
1292
|
+
'NS 生效通常几分钟到几小时;生效后回到面板点「重新检测」,无需重装插件。',
|
|
1293
|
+
],
|
|
1294
|
+
},
|
|
1295
|
+
'ns-mismatch': {
|
|
1296
|
+
title: 'NS 与本账号不一致',
|
|
1297
|
+
banner: '⚠️ 公网 NS 和本账号分配的对不上',
|
|
1298
|
+
note: '本账号里这个域名显示已生效,但公网解析到的 NS 是另一对,说明注册商那边只改了一半或改错了。',
|
|
1299
|
+
steps: [
|
|
1300
|
+
expectedNs.length ? `确认注册商处的两个 NS 都是:${expectedNs.join(' / ')}。` : '确认注册商处的 NS 与 Cloudflare 后台显示的一致。',
|
|
1301
|
+
`当前公网解析到的是:${ns.join(' / ') || '未知'}。`,
|
|
1302
|
+
'改完后等几分钟,回到面板点「重新检测」。',
|
|
1303
|
+
],
|
|
1304
|
+
},
|
|
1305
|
+
unresolved: {
|
|
1306
|
+
title: '记录还没生效',
|
|
1307
|
+
banner: '⚠️ 域名正常,但查不到这条记录',
|
|
1308
|
+
note: '域名在本账号已生效、NS 也对,只是公网还没查到这台主机的记录:多半是刚写入还在传播,或记录被删了。',
|
|
1309
|
+
steps: [
|
|
1310
|
+
'等 1–2 分钟后点「重新检测」。',
|
|
1311
|
+
'仍不行就点「开启远程」重建记录(会写回本机隧道)。',
|
|
1312
|
+
'如果这个地址刚在另一台电脑上开通过,先确认那台是否把记录改指到了它自己的隧道。',
|
|
1313
|
+
],
|
|
1250
1314
|
},
|
|
1315
|
+
};
|
|
1316
|
+
const body = bodies[code] || {
|
|
1317
|
+
title: '域名暂未生效',
|
|
1318
|
+
banner: '⚠️ 公网解析不到这个地址',
|
|
1319
|
+
note: '记录已经写进 Cloudflare,但公网解析不到它。通常是这个域名在当前登录的账号里还没生效。',
|
|
1320
|
+
steps: [
|
|
1321
|
+
'到 Cloudflare 后台看该域名状态是否为「活动 / Active」。',
|
|
1322
|
+
`把域名注册商处的 NS 改成该账号分配的 nameserver${ns.length ? `(当前公网是 ${ns.join('、')})` : ''}。`,
|
|
1323
|
+
'NS 生效后回到面板点「重新检测」即可,无需重装插件。',
|
|
1324
|
+
],
|
|
1325
|
+
};
|
|
1326
|
+
|
|
1327
|
+
showUpdateModal({
|
|
1328
|
+
title: body.title,
|
|
1329
|
+
banner: { text: body.banner, tone: 'warn' },
|
|
1251
1330
|
lines: [
|
|
1252
1331
|
{ label: '固定域名', value: host || '—' },
|
|
1332
|
+
...(zone?.status ? [{ label: '本账号 zone', value: zone.status }] : []),
|
|
1333
|
+
...(nsLine ? [nsLine] : []),
|
|
1253
1334
|
...(ns.length ? [{ label: '公网 NS', value: ns.join(' / ') }] : []),
|
|
1335
|
+
...(accountLine ? [accountLine] : []),
|
|
1254
1336
|
],
|
|
1255
|
-
note:
|
|
1256
|
-
|
|
1257
|
-
: '记录已经写进 Cloudflare,但公网解析不到它。通常是这个域名在当前登录的账号里还没生效:zone 处于 pending,公网 NS 指向另一份 zone。',
|
|
1258
|
-
steps: tampered
|
|
1259
|
-
? [
|
|
1260
|
-
'到 Cloudflare 该域名的 DNS 页面,检查上面这条 CNAME 指向哪里。',
|
|
1261
|
-
'把它改回本机隧道(或直接删除这条记录)。',
|
|
1262
|
-
'回到面板点「重新检测」,通过后重新生成配对码。',
|
|
1263
|
-
]
|
|
1264
|
-
: [
|
|
1265
|
-
'到 Cloudflare 后台看该域名:若状态是「待激活 / Pending」,说明公网 NS 还没指向这个账号。',
|
|
1266
|
-
`把域名注册商处的 NS 改成该账号分配的 nameserver${ns.length ? `(当前公网是 ${ns.join('、')})` : ''}。`,
|
|
1267
|
-
'NS 生效通常几分钟到几小时;生效后回到面板点「重新检测」即可,无需重装插件。',
|
|
1268
|
-
],
|
|
1337
|
+
note: body.note,
|
|
1338
|
+
steps: body.steps,
|
|
1269
1339
|
actions: [
|
|
1270
1340
|
{ label: '关闭', onClick: closeUpdateModal },
|
|
1271
1341
|
{
|
|
@@ -1325,6 +1395,13 @@ window.__ModuleLoader__.load({
|
|
|
1325
1395
|
}
|
|
1326
1396
|
// 域名解析异常:先重检,别把人堵在「暂不可开启」上(那就是原来的死锁)
|
|
1327
1397
|
if (summary?.tunnel?.dnsOk === false) {
|
|
1398
|
+
// 已经确诊「域名被另一个 Cloudflare 账号接管」:重探改变不了归属,
|
|
1399
|
+
// 直接把原因和两条修法摆出来(弹窗里仍有「重新检测」供改完 NS 后收口)。
|
|
1400
|
+
const zone = summary?.tunnel?.zone;
|
|
1401
|
+
if (zone?.code === 'moved') {
|
|
1402
|
+
showDnsHelpModal({ ok: false, zone, publicNs: zone.publicNs || [] });
|
|
1403
|
+
return;
|
|
1404
|
+
}
|
|
1328
1405
|
await recheckDnsAction(banner);
|
|
1329
1406
|
return;
|
|
1330
1407
|
}
|
package/package.json
CHANGED
|
@@ -1,53 +1,53 @@
|
|
|
1
|
-
{
|
|
2
|
-
"name": "dsh-mobile-ios",
|
|
3
|
-
"version": "0.2.
|
|
4
|
-
"type": "module",
|
|
5
|
-
"description": "DSH iOS移动伴侣:iPhone/iPad 扫码连接 DSH 桌面端,局域网直连 + Cloudflare Tunnel 固定域名远程两种通道",
|
|
6
|
-
"main": "entries/plugin.mjs",
|
|
7
|
-
"icon": "assets/brand/plugin-icon.png",
|
|
8
|
-
"engines": {
|
|
9
|
-
"node": ">=20",
|
|
10
|
-
"dsh": ">=0.2.1-alpha.4"
|
|
11
|
-
},
|
|
12
|
-
"keywords": [
|
|
13
|
-
"dsh-plugin",
|
|
14
|
-
"dsh",
|
|
15
|
-
"ios",
|
|
16
|
-
"mobile-companion",
|
|
17
|
-
"pairing"
|
|
18
|
-
],
|
|
19
|
-
"license": "MIT",
|
|
20
|
-
"files": [
|
|
21
|
-
"assets/",
|
|
22
|
-
"entries/",
|
|
23
|
-
"lib/",
|
|
24
|
-
"src/",
|
|
25
|
-
"cordis.patch.yml",
|
|
26
|
-
"README.md",
|
|
27
|
-
"LICENSE"
|
|
28
|
-
],
|
|
29
|
-
"scripts": {
|
|
30
|
-
"start": "node entries/sidecar.mjs --host=mock --dev",
|
|
31
|
-
"start:lan": "node entries/sidecar.mjs --host=mock --dev --lan=true",
|
|
32
|
-
"probe": "node spike0/probe.mjs",
|
|
33
|
-
"test": "node test/selftest.mjs && node test/version.mjs && node test/update-dialog.mjs && node test/ops.mjs && node test/resilience.mjs && node test/borrowed.mjs && node test/mux-table.mjs && node test/live-frames.mjs && node test/artifacts.mjs && node test/attachments.mjs && node test/session-actions.mjs && node test/enhance.mjs && node test/tunnel-named.mjs && node test/cloudflared-install.mjs && node test/install-continue.mjs && node test/dns-recheck.mjs && node test/plugin-selfupdate.mjs"
|
|
34
|
-
},
|
|
35
|
-
"dsh": {
|
|
36
|
-
"bundle": {
|
|
37
|
-
"patch": "./cordis.patch.yml"
|
|
38
|
-
},
|
|
39
|
-
"client": {
|
|
40
|
-
"platform": "web",
|
|
41
|
-
"immediately": true
|
|
42
|
-
}
|
|
43
|
-
},
|
|
44
|
-
"exports": {
|
|
45
|
-
".": {
|
|
46
|
-
"default": "./entries/plugin.mjs"
|
|
47
|
-
},
|
|
48
|
-
"./client": {
|
|
49
|
-
"default": "./lib/client.js"
|
|
50
|
-
},
|
|
51
|
-
"./package.json": "./package.json"
|
|
52
|
-
}
|
|
53
|
-
}
|
|
1
|
+
{
|
|
2
|
+
"name": "dsh-mobile-ios",
|
|
3
|
+
"version": "0.2.10",
|
|
4
|
+
"type": "module",
|
|
5
|
+
"description": "DSH iOS移动伴侣:iPhone/iPad 扫码连接 DSH 桌面端,局域网直连 + Cloudflare Tunnel 固定域名远程两种通道",
|
|
6
|
+
"main": "entries/plugin.mjs",
|
|
7
|
+
"icon": "assets/brand/plugin-icon.png",
|
|
8
|
+
"engines": {
|
|
9
|
+
"node": ">=20",
|
|
10
|
+
"dsh": ">=0.2.1-alpha.4"
|
|
11
|
+
},
|
|
12
|
+
"keywords": [
|
|
13
|
+
"dsh-plugin",
|
|
14
|
+
"dsh",
|
|
15
|
+
"ios",
|
|
16
|
+
"mobile-companion",
|
|
17
|
+
"pairing"
|
|
18
|
+
],
|
|
19
|
+
"license": "MIT",
|
|
20
|
+
"files": [
|
|
21
|
+
"assets/",
|
|
22
|
+
"entries/",
|
|
23
|
+
"lib/",
|
|
24
|
+
"src/",
|
|
25
|
+
"cordis.patch.yml",
|
|
26
|
+
"README.md",
|
|
27
|
+
"LICENSE"
|
|
28
|
+
],
|
|
29
|
+
"scripts": {
|
|
30
|
+
"start": "node entries/sidecar.mjs --host=mock --dev",
|
|
31
|
+
"start:lan": "node entries/sidecar.mjs --host=mock --dev --lan=true",
|
|
32
|
+
"probe": "node spike0/probe.mjs",
|
|
33
|
+
"test": "node test/selftest.mjs && node test/version.mjs && node test/update-dialog.mjs && node test/ops.mjs && node test/resilience.mjs && node test/borrowed.mjs && node test/mux-table.mjs && node test/live-frames.mjs && node test/artifacts.mjs && node test/attachments.mjs && node test/session-actions.mjs && node test/enhance.mjs && node test/tunnel-named.mjs && node test/cloudflared-install.mjs && node test/install-continue.mjs && node test/dns-recheck.mjs && node test/plugin-selfupdate.mjs && node test/zone-moved.mjs"
|
|
34
|
+
},
|
|
35
|
+
"dsh": {
|
|
36
|
+
"bundle": {
|
|
37
|
+
"patch": "./cordis.patch.yml"
|
|
38
|
+
},
|
|
39
|
+
"client": {
|
|
40
|
+
"platform": "web",
|
|
41
|
+
"immediately": true
|
|
42
|
+
}
|
|
43
|
+
},
|
|
44
|
+
"exports": {
|
|
45
|
+
".": {
|
|
46
|
+
"default": "./entries/plugin.mjs"
|
|
47
|
+
},
|
|
48
|
+
"./client": {
|
|
49
|
+
"default": "./lib/client.js"
|
|
50
|
+
},
|
|
51
|
+
"./package.json": "./package.json"
|
|
52
|
+
}
|
|
53
|
+
}
|
package/src/cloudflare.mjs
CHANGED
|
@@ -22,7 +22,8 @@ import path from 'node:path';
|
|
|
22
22
|
import { fail } from './protocol.mjs';
|
|
23
23
|
import { deriveSubdomain, isValidLabel } from './dns-label.mjs';
|
|
24
24
|
import { DNS_PENDING_HINT, DNS_TAMPER_HINT, dnsWarningFor, evaluateDnsAnswer, probeDns } from './dns-probe.mjs';
|
|
25
|
-
import { LocalProvisioner } from './provision-local.mjs';
|
|
25
|
+
import { LocalProvisioner, sanitizeZone } from './provision-local.mjs';
|
|
26
|
+
import { diagnoseZone, findDnsOwner, ZONE_STATUS_HINT } from './zone-health.mjs';
|
|
26
27
|
|
|
27
28
|
// 兼容既有调用方与测试:子域规则从 dns-label.mjs 来,这里一并导出
|
|
28
29
|
export { deriveSubdomain, isValidLabel };
|
|
@@ -72,13 +73,16 @@ function saveState(file, state) {
|
|
|
72
73
|
}
|
|
73
74
|
|
|
74
75
|
class BaseProvisioner {
|
|
75
|
-
constructor({ stateFile = null, log = () => {}, baseDomain = 'matrixboard.cn', probe = null } = {}) {
|
|
76
|
+
constructor({ stateFile = null, log = () => {}, baseDomain = 'matrixboard.cn', probe = null, zoneDiagnose = null } = {}) {
|
|
76
77
|
this.stateFile = stateFile;
|
|
77
78
|
this.log = log;
|
|
78
79
|
this.baseDomain = String(baseDomain).replace(/^\./, '').toLowerCase();
|
|
79
80
|
this._state = undefined; // undefined=未读;null=没有
|
|
80
81
|
// 可注入:测试里不该真发 DNS 查询(依赖外网且要等重试)
|
|
81
82
|
this.probe = probe || probeDns;
|
|
83
|
+
// 解析失败时进一步归因(moved / pending / ns-mismatch);不注入就只报「解析不到」
|
|
84
|
+
this.zoneDiagnose = zoneDiagnose;
|
|
85
|
+
this._zone = null;
|
|
82
86
|
}
|
|
83
87
|
|
|
84
88
|
/**
|
|
@@ -96,8 +100,25 @@ class BaseProvisioner {
|
|
|
96
100
|
// 记录若被人改指到别的隧道/服务器,解析照样「成功」,流量却会落到对方 ingress——
|
|
97
101
|
// 这时按「地址不可用」处理,绝不下发。
|
|
98
102
|
const verdict = evaluateDnsAnswer(check, current?.tunnelId);
|
|
103
|
+
// 解析不到时再问一句「这域名现在归谁」:moved(被别的账号接管)与 pending(NS 还没指过来)
|
|
104
|
+
// 的修法完全不同,笼统一句「等 NS 生效」会让人白等。
|
|
105
|
+
let zone = null;
|
|
106
|
+
if (!verdict.ok && typeof this.zoneDiagnose === 'function') {
|
|
107
|
+
try {
|
|
108
|
+
zone = sanitizeZone(await this.zoneDiagnose({ baseDomain: this.baseDomain, dnsOk: false }));
|
|
109
|
+
} catch {
|
|
110
|
+
zone = null;
|
|
111
|
+
}
|
|
112
|
+
this._zone = zone;
|
|
113
|
+
}
|
|
99
114
|
if (current && current.hostname === hostname) {
|
|
100
|
-
this.#persist({
|
|
115
|
+
this.#persist({
|
|
116
|
+
...current,
|
|
117
|
+
dnsOk: verdict.ok,
|
|
118
|
+
dnsTampered: verdict.tampered,
|
|
119
|
+
dnsCheckedAt: new Date().toISOString(),
|
|
120
|
+
zone,
|
|
121
|
+
});
|
|
101
122
|
}
|
|
102
123
|
if (verdict.tampered) {
|
|
103
124
|
this.log(`tunnel 警告 固定地址解析被改指 ${hostname} → ${verdict.target}(期望 ${verdict.expected}),拒绝下发该地址`);
|
|
@@ -115,7 +136,7 @@ class BaseProvisioner {
|
|
|
115
136
|
*/
|
|
116
137
|
async recheckDns() {
|
|
117
138
|
const s = this.state;
|
|
118
|
-
if (!s?.hostname) return { provisioned: false, ok: false, tampered: false, warning: null };
|
|
139
|
+
if (!s?.hostname) return { provisioned: false, ok: false, tampered: false, warning: null, zone: null };
|
|
119
140
|
const verdict = await this.verifyDns(s.hostname);
|
|
120
141
|
const now = this.state;
|
|
121
142
|
return {
|
|
@@ -127,6 +148,7 @@ class BaseProvisioner {
|
|
|
127
148
|
target: verdict.target ?? null,
|
|
128
149
|
warning: dnsWarningFor(now),
|
|
129
150
|
checkedAt: now.dnsCheckedAt ?? null,
|
|
151
|
+
zone: now.zone ?? this._zone ?? null,
|
|
130
152
|
};
|
|
131
153
|
}
|
|
132
154
|
|
|
@@ -165,6 +187,7 @@ class BaseProvisioner {
|
|
|
165
187
|
// null = 还没验过;true/false = 验过且结论明确
|
|
166
188
|
dnsOk: s.dnsOk ?? null,
|
|
167
189
|
dnsCheckedAt: s.dnsCheckedAt ?? null,
|
|
190
|
+
zone: s.zone ?? this._zone ?? null,
|
|
168
191
|
warning: dnsWarningFor(s),
|
|
169
192
|
createdAt: s.createdAt ?? null,
|
|
170
193
|
updatedAt: s.updatedAt ?? null,
|
|
@@ -266,8 +289,9 @@ export class CloudflareProvisioner extends BaseProvisioner {
|
|
|
266
289
|
apiBase = CF_API_BASE,
|
|
267
290
|
log = () => {},
|
|
268
291
|
probe = null,
|
|
292
|
+
zoneDiagnose = null,
|
|
269
293
|
} = {}) {
|
|
270
|
-
super({ stateFile, log, baseDomain, probe });
|
|
294
|
+
super({ stateFile, log, baseDomain, probe, zoneDiagnose });
|
|
271
295
|
this.apiToken = apiToken;
|
|
272
296
|
this.accountId = accountId;
|
|
273
297
|
this.zoneId = zoneId;
|
|
@@ -275,6 +299,15 @@ export class CloudflareProvisioner extends BaseProvisioner {
|
|
|
275
299
|
this.seed = seed;
|
|
276
300
|
this.fetchImpl = fetchImpl;
|
|
277
301
|
this.apiBase = String(apiBase).replace(/\/$/, '');
|
|
302
|
+
// API 形态本身就有 zone 级凭据,不必借 cert.pem:解析失败时直接问清 zone 现状
|
|
303
|
+
this.zoneDiagnose = zoneDiagnose || ((args = {}) => diagnoseZone({
|
|
304
|
+
...args,
|
|
305
|
+
apiToken: this.apiToken,
|
|
306
|
+
zoneId: this.zoneId,
|
|
307
|
+
baseDomain: args.baseDomain || this.baseDomain,
|
|
308
|
+
fetchImpl: this.fetchImpl,
|
|
309
|
+
apiBase: this.apiBase,
|
|
310
|
+
}));
|
|
278
311
|
}
|
|
279
312
|
|
|
280
313
|
get kind() {
|
|
@@ -361,8 +394,17 @@ export class CloudflareProvisioner extends BaseProvisioner {
|
|
|
361
394
|
});
|
|
362
395
|
}
|
|
363
396
|
if (zone.status && zone.status !== 'active') {
|
|
364
|
-
|
|
365
|
-
|
|
397
|
+
// 状态不同,修法完全不同:moved 说明域名已被另一个 Cloudflare 账号接管,
|
|
398
|
+
// 在本账号重试一万次也不会生效;pending 只是 NS 还没指过来。
|
|
399
|
+
const hint = ZONE_STATUS_HINT[zone.status] || `状态 ${zone.status}`;
|
|
400
|
+
const ns = (zone.name_servers || []).join(' / ') || '(当前账号未分配)';
|
|
401
|
+
throw fail(4021, `域名 ${this.baseDomain} 未生效:${hint}`, {
|
|
402
|
+
detail: zone.status === 'moved'
|
|
403
|
+
? `本账号分配的公网 NS 是 ${ns}。域名现在被另一个 Cloudflare 账号接管,本账号写入的记录不会下发——`
|
|
404
|
+
+ '要么在注册商把 NS 改回这一对,要么统一只用同一个 Cloudflare 账号登录(两边互斥,只能二选一)。'
|
|
405
|
+
: `本账号分配的公网 NS 是 ${ns};到域名注册商把 NS 改成这一对,生效后再开通。`,
|
|
406
|
+
zoneStatus: zone.status,
|
|
407
|
+
expectedNs: zone.name_servers || [],
|
|
366
408
|
});
|
|
367
409
|
}
|
|
368
410
|
this.zoneId = zone.id;
|
|
@@ -626,6 +668,9 @@ export function createProvisioner(config = {}, { log = () => {}, stateFile = nul
|
|
|
626
668
|
configFile: config.configFile || null,
|
|
627
669
|
seed: config.seed || null,
|
|
628
670
|
log,
|
|
671
|
+
// 生产路径才接真实探测:测试直接 new LocalProvisioner 时保持零网络依赖
|
|
672
|
+
zoneDiagnose: diagnoseZone,
|
|
673
|
+
ownerLookup: findDnsOwner,
|
|
629
674
|
});
|
|
630
675
|
}
|
|
631
676
|
if (kind === 'state') {
|
package/src/dns-probe.mjs
CHANGED
|
@@ -10,9 +10,22 @@
|
|
|
10
10
|
|
|
11
11
|
import dns from 'node:dns';
|
|
12
12
|
|
|
13
|
-
export const DNS_PENDING_HINT = '域名在当前 Cloudflare
|
|
13
|
+
export const DNS_PENDING_HINT = '域名在当前 Cloudflare 账号里还没生效(zone pending):公网 NS 指向的是另一份 zone。'
|
|
14
14
|
+ '要么把这个域名的 NS 改成该账号分配的 nameserver,要么换用持有生效 zone 的账号重新登录授权。';
|
|
15
15
|
|
|
16
|
+
// 本账号的 zone 已被另一个 Cloudflare 账号接管(status=moved)。这时改本账号的
|
|
17
|
+
// 记录、重装插件、重启隧道统统没用——公网根本不读这份 zone,必须动注册商 NS 或换账号。
|
|
18
|
+
export const DNS_MOVED_HINT = '域名已被另一个 Cloudflare 账号接管(zone moved):本机写入的记录不会下发到公网。'
|
|
19
|
+
+ '在域名注册商处把 NS 改回本账号分配的一对,或统一只用同一个 Cloudflare 账号登录。';
|
|
20
|
+
|
|
21
|
+
export const DNS_NS_MISMATCH_HINT = '域名在本账号显示已生效,但公网 NS 与本账号分配的不一致,记录暂时查不到。'
|
|
22
|
+
+ '确认注册商处两处 NS 都已改完,再点「重新检测」。';
|
|
23
|
+
|
|
24
|
+
// zone 已 active、NS 也对,公网却还是没有这条记录:多半是刚写入的记录还在传播,
|
|
25
|
+
// 或者记录被手动删了。这时重装/重开都没意义,等一下再重检即可。
|
|
26
|
+
export const DNS_UNRESOLVED_HINT = '域名在 Cloudflare 已生效,但公网暂时查不到这台主机的记录:'
|
|
27
|
+
+ '记录可能刚写入(等 1–2 分钟),或已被删除。稍后点「重新检测」,仍不行就重新「开启远程」重建记录。';
|
|
28
|
+
|
|
16
29
|
// 防劫持:CNAME 没有指向本机隧道。解析「成功」但流量会落到别人的 ingress,
|
|
17
30
|
// 扫码连接等于把指令发给未知服务器——必须当作地址不可用处理。
|
|
18
31
|
export const DNS_TAMPER_HINT = '固定域名解析异常:CNAME 已不指向本机隧道(可能被篡改或误改)。'
|
|
@@ -33,11 +46,18 @@ export function evaluateDnsAnswer(check, tunnelId) {
|
|
|
33
46
|
return { ...check, ok: Boolean(check?.ok) && !tampered, tampered, target, expected };
|
|
34
47
|
}
|
|
35
48
|
|
|
36
|
-
/** 状态 → 面板提示。篡改优先于
|
|
49
|
+
/** 状态 → 面板提示。篡改优先于 zone 故障:两者都真时,先让人处理更危险的那个。 */
|
|
37
50
|
export function dnsWarningFor(state) {
|
|
38
51
|
if (state?.dnsTampered) return DNS_TAMPER_HINT;
|
|
39
|
-
if (state?.dnsOk
|
|
40
|
-
|
|
52
|
+
if (state?.dnsOk !== false) return null;
|
|
53
|
+
// zone 层面已经诊断出结论时,用结论而不是笼统的「pending」——
|
|
54
|
+
// moved / pending / ns-mismatch 的修法完全不同,猜错等于让人白跑一趟。
|
|
55
|
+
const code = state?.zone?.code;
|
|
56
|
+
if (code === 'moved') return DNS_MOVED_HINT;
|
|
57
|
+
if (code === 'ns-mismatch') return DNS_NS_MISMATCH_HINT;
|
|
58
|
+
if (code === 'unresolved') return DNS_UNRESOLVED_HINT;
|
|
59
|
+
if (code === 'pending') return DNS_PENDING_HINT;
|
|
60
|
+
return DNS_PENDING_HINT;
|
|
41
61
|
}
|
|
42
62
|
|
|
43
63
|
/**
|
package/src/provision-local.mjs
CHANGED
|
@@ -22,7 +22,8 @@ import { execFile as nodeExecFile } from 'node:child_process';
|
|
|
22
22
|
import { promisify } from 'node:util';
|
|
23
23
|
import { fail } from './protocol.mjs';
|
|
24
24
|
import { deriveSubdomain, isValidLabel } from './dns-label.mjs';
|
|
25
|
-
import { dnsWarningFor, evaluateDnsAnswer, probeDns } from './dns-probe.mjs';
|
|
25
|
+
import { dnsWarningFor, evaluateDnsAnswer, probeDns, resolveNs } from './dns-probe.mjs';
|
|
26
|
+
import { cnameBelongsTo } from './zone-health.mjs';
|
|
26
27
|
|
|
27
28
|
const execFileAsync = promisify(nodeExecFile);
|
|
28
29
|
const CLI_TIMEOUT_MS = 45_000;
|
|
@@ -66,6 +67,26 @@ export function renderConfig({ tunnelId, credentialsFile, hostname, port }) {
|
|
|
66
67
|
].join('\n');
|
|
67
68
|
}
|
|
68
69
|
|
|
70
|
+
/**
|
|
71
|
+
* zone 诊断结果的**展示副本**:只留结论与 NS 名字。
|
|
72
|
+
*
|
|
73
|
+
* zoneId / accountId 这类内部标识一律不落状态文件、不进面板——
|
|
74
|
+
* 面板只需要知道「归谁、对不对」,不需要也不该拿到账号坐标。
|
|
75
|
+
*/
|
|
76
|
+
export function sanitizeZone(zone) {
|
|
77
|
+
if (!zone || typeof zone !== 'object') return null;
|
|
78
|
+
const list = (v) => (Array.isArray(v) ? v.map((x) => String(x).toLowerCase()).filter(Boolean).slice(0, 4) : []);
|
|
79
|
+
return {
|
|
80
|
+
code: zone.code || 'unknown',
|
|
81
|
+
status: zone.status || null,
|
|
82
|
+
expectedNs: list(zone.expectedNs),
|
|
83
|
+
publicNs: list(zone.publicNs),
|
|
84
|
+
zoneName: zone.zoneName || null,
|
|
85
|
+
accountName: zone.accountName || null,
|
|
86
|
+
checkedAt: new Date().toISOString(),
|
|
87
|
+
};
|
|
88
|
+
}
|
|
89
|
+
|
|
69
90
|
export class LocalProvisioner {
|
|
70
91
|
constructor({
|
|
71
92
|
baseDomain = 'matrixboard.cn',
|
|
@@ -79,6 +100,11 @@ export class LocalProvisioner {
|
|
|
79
100
|
run = null,
|
|
80
101
|
// 可注入:测试里不该真发 DNS 查询(会等 NXDOMAIN 重试,还依赖外网)
|
|
81
102
|
probe = null,
|
|
103
|
+
// 可注入:解析失败时进一步问「这个域名现在归哪个 Cloudflare 账号」。
|
|
104
|
+
// 不注入就不诊断(测试/离线场景保持零网络依赖);生产由 createProvisioner 注入。
|
|
105
|
+
zoneDiagnose = null,
|
|
106
|
+
// 可注入:开通前查这条 hostname 现在指向哪条隧道,避免多机互相覆盖。
|
|
107
|
+
ownerLookup = null,
|
|
82
108
|
} = {}) {
|
|
83
109
|
this.baseDomain = String(baseDomain).replace(/^\./, '').toLowerCase();
|
|
84
110
|
this.prefix = prefix;
|
|
@@ -92,6 +118,9 @@ export class LocalProvisioner {
|
|
|
92
118
|
// 可注入,测试里不必真起 cloudflared
|
|
93
119
|
this.run = run || this.#exec;
|
|
94
120
|
this.probe = probe || probeDns;
|
|
121
|
+
this.zoneDiagnose = zoneDiagnose;
|
|
122
|
+
this.ownerLookup = ownerLookup;
|
|
123
|
+
this._zone = null; // 最近一次 zone 诊断结论(不含凭据)
|
|
95
124
|
}
|
|
96
125
|
|
|
97
126
|
get kind() {
|
|
@@ -117,6 +146,43 @@ export class LocalProvisioner {
|
|
|
117
146
|
return `在这台电脑的终端执行:${this.executable} tunnel login(浏览器里选 matrixboard.cn 授权)`;
|
|
118
147
|
}
|
|
119
148
|
|
|
149
|
+
/** 公网当前 NS(查询失败就当没有:少一句提示不该让整条诊断崩掉)。 */
|
|
150
|
+
async #publicNs() {
|
|
151
|
+
try {
|
|
152
|
+
return await resolveNs(this.baseDomain);
|
|
153
|
+
} catch {
|
|
154
|
+
return [];
|
|
155
|
+
}
|
|
156
|
+
}
|
|
157
|
+
|
|
158
|
+
/**
|
|
159
|
+
* 解析自检 + (失败时)zone 归因。
|
|
160
|
+
*
|
|
161
|
+
* 只把「解析不到」当作需要归因的信号:解析成功时多问一次 Cloudflare 只是浪费
|
|
162
|
+
* 一次往返,而失败时那句笼统的「pending」正是把人带偏的根源——域名可能已经被
|
|
163
|
+
* 另一个 Cloudflare 账号接管(zone moved),改 NS、重装、重启都不可能修好。
|
|
164
|
+
*/
|
|
165
|
+
async #evaluate(hostname, tunnelId) {
|
|
166
|
+
const verdict = evaluateDnsAnswer(await this.probe(hostname), tunnelId);
|
|
167
|
+
if (verdict.ok || typeof this.zoneDiagnose !== 'function') {
|
|
168
|
+
this._zone = null; // 通了就别留着上一次的故障结论
|
|
169
|
+
return { verdict, zone: null };
|
|
170
|
+
}
|
|
171
|
+
let zone = null;
|
|
172
|
+
try {
|
|
173
|
+
zone = sanitizeZone(await this.zoneDiagnose({
|
|
174
|
+
homeDir: this.homeDir,
|
|
175
|
+
baseDomain: this.baseDomain,
|
|
176
|
+
publicNs: await this.#publicNs(),
|
|
177
|
+
dnsOk: false,
|
|
178
|
+
}));
|
|
179
|
+
} catch {
|
|
180
|
+
zone = null; // 「不知道」比「猜一个」诚实
|
|
181
|
+
}
|
|
182
|
+
this._zone = zone;
|
|
183
|
+
return { verdict, zone };
|
|
184
|
+
}
|
|
185
|
+
|
|
120
186
|
status() {
|
|
121
187
|
const s = this.state;
|
|
122
188
|
if (!s) return { kind: 'local', provisioned: false, hostname: null, url: null, tunnelId: null };
|
|
@@ -130,6 +196,9 @@ export class LocalProvisioner {
|
|
|
130
196
|
// null = 还没验过(老状态文件);false = 验过但公网没有——面板必须提示,别让人扫码扫到空气
|
|
131
197
|
dnsOk: s.dnsOk ?? null,
|
|
132
198
|
dnsCheckedAt: s.dnsCheckedAt ?? null,
|
|
199
|
+
// 失败原因归到 zone 层(moved / pending / ns-mismatch / unresolved),
|
|
200
|
+
// 面板据此给出**不同**的修法,而不是一律「等 NS 生效」。
|
|
201
|
+
zone: s.zone ?? this._zone ?? null,
|
|
133
202
|
warning: dnsWarningFor(s),
|
|
134
203
|
createdAt: s.createdAt ?? null,
|
|
135
204
|
updatedAt: s.updatedAt ?? null,
|
|
@@ -145,13 +214,14 @@ export class LocalProvisioner {
|
|
|
145
214
|
*/
|
|
146
215
|
async recheckDns() {
|
|
147
216
|
const s = this.state;
|
|
148
|
-
if (!s?.hostname) return { provisioned: false, ok: false, tampered: false, warning: null, publicNs: [] };
|
|
149
|
-
const verdict =
|
|
217
|
+
if (!s?.hostname) return { provisioned: false, ok: false, tampered: false, warning: null, publicNs: [], zone: null };
|
|
218
|
+
const { verdict, zone } = await this.#evaluate(s.hostname, s.tunnelId);
|
|
150
219
|
const next = {
|
|
151
220
|
...s,
|
|
152
221
|
dnsOk: verdict.ok,
|
|
153
222
|
dnsTampered: verdict.tampered,
|
|
154
223
|
dnsCheckedAt: new Date().toISOString(),
|
|
224
|
+
zone,
|
|
155
225
|
};
|
|
156
226
|
this._state = next;
|
|
157
227
|
writeState(this.stateFile, next);
|
|
@@ -164,6 +234,7 @@ export class LocalProvisioner {
|
|
|
164
234
|
target: verdict.target ?? null,
|
|
165
235
|
warning: dnsWarningFor(next),
|
|
166
236
|
checkedAt: next.dnsCheckedAt,
|
|
237
|
+
zone,
|
|
167
238
|
};
|
|
168
239
|
}
|
|
169
240
|
|
|
@@ -201,8 +272,14 @@ export class LocalProvisioner {
|
|
|
201
272
|
if (!force && cached?.hostname && cached.port === port) {
|
|
202
273
|
// 与 BaseProvisioner 同策略:没确认过就现场验一次(含防篡改评估)
|
|
203
274
|
if (cached.dnsOk !== true) {
|
|
204
|
-
const verdict =
|
|
205
|
-
const next = {
|
|
275
|
+
const { verdict, zone } = await this.#evaluate(cached.hostname, cached.tunnelId);
|
|
276
|
+
const next = {
|
|
277
|
+
...cached,
|
|
278
|
+
dnsOk: verdict.ok,
|
|
279
|
+
dnsTampered: verdict.tampered,
|
|
280
|
+
dnsCheckedAt: new Date().toISOString(),
|
|
281
|
+
zone,
|
|
282
|
+
};
|
|
206
283
|
this._state = next;
|
|
207
284
|
writeState(this.stateFile, next);
|
|
208
285
|
return {
|
|
@@ -212,6 +289,7 @@ export class LocalProvisioner {
|
|
|
212
289
|
created: false,
|
|
213
290
|
changed: false,
|
|
214
291
|
dnsOk: next.dnsOk,
|
|
292
|
+
zone,
|
|
215
293
|
warning: dnsWarningFor(next),
|
|
216
294
|
};
|
|
217
295
|
}
|
|
@@ -278,6 +356,25 @@ export class LocalProvisioner {
|
|
|
278
356
|
});
|
|
279
357
|
}
|
|
280
358
|
|
|
359
|
+
// 多机共用同一个 Cloudflare 账号时,`--overwrite-dns` 会**静默**把别人的地址抢走:
|
|
360
|
+
// A 机本来能用,B 机一开通 A 机就断,两边面板却都显示「成功」。
|
|
361
|
+
// 有凭据就先看这条 hostname 现在归谁,抢址直接报错,绝不静默覆盖。
|
|
362
|
+
if (typeof this.ownerLookup === 'function') {
|
|
363
|
+
let owner = null;
|
|
364
|
+
try {
|
|
365
|
+
owner = await this.ownerLookup({ homeDir: this.homeDir, baseDomain: this.baseDomain, hostname });
|
|
366
|
+
} catch {
|
|
367
|
+
owner = null; // 查不到归属时退回旧行为,别让诊断把开通卡死
|
|
368
|
+
}
|
|
369
|
+
if (owner && !cnameBelongsTo(owner, tunnelId)) {
|
|
370
|
+
this.log(`tunnel 拒绝覆盖 ${hostname}:当前指向 ${owner},本机隧道 ${tunnelId}`);
|
|
371
|
+
throw fail(4021, `固定地址 ${hostname} 已被另一条隧道占用`, {
|
|
372
|
+
detail: `该地址当前指向 ${owner}。通常是另一台电脑用了同一份安装标识(或状态文件被复制)。`
|
|
373
|
+
+ '本机已停止覆盖它:请在那台设备上重新开通以换一个地址,或先删掉这条 DNS 记录再重试。',
|
|
374
|
+
});
|
|
375
|
+
}
|
|
376
|
+
}
|
|
377
|
+
|
|
281
378
|
// --overwrite-dns:重复开通时把记录改到当前 tunnel,而不是报「已存在」
|
|
282
379
|
try {
|
|
283
380
|
await this.run(['tunnel', 'route', 'dns', '--overwrite-dns', label, hostname]);
|
|
@@ -292,10 +389,10 @@ export class LocalProvisioner {
|
|
|
292
389
|
try { fs.chmodSync(this.configFile, 0o600); } catch { /* 已 0600 */ }
|
|
293
390
|
|
|
294
391
|
const now = new Date().toISOString();
|
|
295
|
-
// 开通即自检:DNS 写成功 ≠ 公网能解析(pending zone 就是这么骗人的);
|
|
392
|
+
// 开通即自检:DNS 写成功 ≠ 公网能解析(pending / moved zone 就是这么骗人的);
|
|
296
393
|
// CNAME 被改指到别的隧道同样不放行(防劫持评估见 dns-probe.evaluateDnsAnswer)
|
|
297
|
-
const verdict =
|
|
298
|
-
const warning = dnsWarningFor({ dnsOk: verdict.ok, dnsTampered: verdict.tampered });
|
|
394
|
+
const { verdict, zone } = await this.#evaluate(hostname, tunnelId);
|
|
395
|
+
const warning = dnsWarningFor({ dnsOk: verdict.ok, dnsTampered: verdict.tampered, zone });
|
|
299
396
|
if (verdict.tampered) {
|
|
300
397
|
this.log(`tunnel 警告 固定地址解析被改指 ${hostname} → ${verdict.target}(期望 ${verdict.expected}),拒绝下发该地址`);
|
|
301
398
|
} else if (verdict.ok) {
|
|
@@ -316,6 +413,7 @@ export class LocalProvisioner {
|
|
|
316
413
|
dnsOk: verdict.ok,
|
|
317
414
|
dnsTampered: verdict.tampered,
|
|
318
415
|
dnsCheckedAt: now,
|
|
416
|
+
zone,
|
|
319
417
|
createdAt: cached?.createdAt ?? now,
|
|
320
418
|
updatedAt: now,
|
|
321
419
|
};
|
|
@@ -329,6 +427,7 @@ export class LocalProvisioner {
|
|
|
329
427
|
created,
|
|
330
428
|
changed: Boolean(cached && cached.hostname !== hostname),
|
|
331
429
|
dnsOk: verdict.ok,
|
|
430
|
+
zone,
|
|
332
431
|
warning,
|
|
333
432
|
};
|
|
334
433
|
}
|
package/src/rest.mjs
CHANGED
|
@@ -259,6 +259,9 @@ export function createRestRouter({ core, pairing, host, tickets, config = {}, lo
|
|
|
259
259
|
// 面板与二维码都要据此避开它,而不是让用户拿一个必然失败的地址去扫。
|
|
260
260
|
dnsOk: prov?.dnsOk ?? null,
|
|
261
261
|
dnsCheckedAt: prov?.dnsCheckedAt ?? null,
|
|
262
|
+
// 解析失败的归因(moved / pending / ns-mismatch / unresolved):
|
|
263
|
+
// 面板据此给**不同**的修法,而不是一律「等 NS 生效」。
|
|
264
|
+
zone: prov?.zone ?? null,
|
|
262
265
|
warning: prov?.warning ?? null,
|
|
263
266
|
// 面板据此决定是否显示「自动安装 cloudflared」入口:仅在缺失且有官方构建时为 true。
|
|
264
267
|
canAutoInstall: base.executable === 'missing' && !!resolveAsset({}),
|
|
@@ -0,0 +1,251 @@
|
|
|
1
|
+
// zone-health.mjs — 「域名到底归谁、公网到底在服务哪一份 zone」
|
|
2
|
+
//
|
|
3
|
+
// 为什么需要这个模块:DNS 解析失败只是**症状**,原因是 zone 层面的事,而面板原来
|
|
4
|
+
// 一律解释成「zone 处于 pending」——这在真实世界里会把人带偏。
|
|
5
|
+
//
|
|
6
|
+
// Cloudflare 的 zone 有四种会让地址「开通成功但解析不到」的状态:
|
|
7
|
+
// · active 公网 NS 指向本账号、记录正常下发 —— 正常
|
|
8
|
+
// · pending 域名已加进本账号,但注册商 NS 还没指过来 —— 改 NS 即可
|
|
9
|
+
// · moved 域名已被**另一个 Cloudflare 账号**接管 —— 本账号写什么都无效,
|
|
10
|
+
// 公网 NS 是对方那一对(每个账号的 NS 对是固定的,所以能直接看出来)
|
|
11
|
+
// · 记录在某台机器上被 --overwrite-dns 改指到另一条隧道 —— 见 findDnsOwner()
|
|
12
|
+
//
|
|
13
|
+
// 本机 `cloudflared tunnel login` 生成的 cert.pem 里就带着 zoneID / accountID /
|
|
14
|
+
// 一份 zone 范围的 apiToken,因此**不需要额外凭据**就能只读地问清 zone 状态。
|
|
15
|
+
// 这里只做 GET,绝不写;token 只在函数内部流转,不进状态文件、不进日志。
|
|
16
|
+
//
|
|
17
|
+
// 另一条硬约束:所有失败都必须**降级为 null**(返回「不知道」),不能让一个
|
|
18
|
+
// 查不到状态的网络问题把本来能用的固定地址判死。
|
|
19
|
+
|
|
20
|
+
import crypto from 'node:crypto';
|
|
21
|
+
import fs from 'node:fs';
|
|
22
|
+
import os from 'node:os';
|
|
23
|
+
import path from 'node:path';
|
|
24
|
+
|
|
25
|
+
export const CF_API_BASE = 'https://api.cloudflare.com/client/v4';
|
|
26
|
+
|
|
27
|
+
/** zone 状态码 → 面板可读的一句话(短,塞得进 300px 宽的面板)。 */
|
|
28
|
+
export const ZONE_STATUS_HINT = {
|
|
29
|
+
active: '域名在 Cloudflare 已生效',
|
|
30
|
+
pending: '域名在本账号尚未生效(zone pending),公网 NS 没指向本账号',
|
|
31
|
+
moved: '域名已被另一个 Cloudflare 账号接管(zone moved),本账号写入的记录不再下发',
|
|
32
|
+
initializing: '域名正在本账号初始化(zone initializing)',
|
|
33
|
+
};
|
|
34
|
+
|
|
35
|
+
/** 诊断码 → 短提示。code 比 status 更适合面板:它已经带上了「NS 对不对」的结论。 */
|
|
36
|
+
export const ZONE_CODE_HINT = {
|
|
37
|
+
moved: '域名已被另一个 Cloudflare 账号接管,公网 NS 指向对方,本机写入的记录不会生效',
|
|
38
|
+
pending: '域名在本账号还没生效(zone pending):公网 NS 还没指向本账号分配的那一对',
|
|
39
|
+
'ns-mismatch': '域名在本账号显示已生效,但公网 NS 与本账号分配的不一致',
|
|
40
|
+
unresolved: '域名在 Cloudflare 已生效,但公网仍解析不到这台主机的地址',
|
|
41
|
+
};
|
|
42
|
+
|
|
43
|
+
/**
|
|
44
|
+
* 读 cert.pem 里的 zone 身份。结构是 PEM 包一层 base64(JSON)。
|
|
45
|
+
* @returns {{ zoneId: string|null, accountId: string|null, apiToken: string|null }|null}
|
|
46
|
+
*/
|
|
47
|
+
export function readZoneCert({ homeDir = os.homedir() } = {}) {
|
|
48
|
+
const file = path.join(homeDir, '.cloudflared', 'cert.pem');
|
|
49
|
+
let pem;
|
|
50
|
+
try {
|
|
51
|
+
pem = fs.readFileSync(file, 'utf8');
|
|
52
|
+
} catch {
|
|
53
|
+
return null;
|
|
54
|
+
}
|
|
55
|
+
try {
|
|
56
|
+
const b64 = pem.replace(/-----[^-]+-----/g, '').replace(/\s+/g, '');
|
|
57
|
+
const parsed = JSON.parse(Buffer.from(b64, 'base64').toString('utf8'));
|
|
58
|
+
return {
|
|
59
|
+
zoneId: parsed.zoneID || parsed.zoneId || null,
|
|
60
|
+
accountId: parsed.accountID || parsed.accountId || null,
|
|
61
|
+
apiToken: parsed.apiToken || null,
|
|
62
|
+
};
|
|
63
|
+
} catch {
|
|
64
|
+
return null;
|
|
65
|
+
}
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
async function cfGet(apiBase, apiToken, pathname, fetchImpl) {
|
|
69
|
+
const res = await fetchImpl(`${apiBase}${pathname}`, {
|
|
70
|
+
headers: { Authorization: `Bearer ${apiToken}` },
|
|
71
|
+
});
|
|
72
|
+
const text = await res.text();
|
|
73
|
+
let payload = null;
|
|
74
|
+
try {
|
|
75
|
+
payload = text ? JSON.parse(text) : null;
|
|
76
|
+
} catch {
|
|
77
|
+
return null;
|
|
78
|
+
}
|
|
79
|
+
if (!payload || payload.success !== true) return null;
|
|
80
|
+
return payload.result;
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
/**
|
|
84
|
+
* 查 zone 现状:状态 + **这个账号要求**的 NS 对 + 账号名。
|
|
85
|
+
* 任一环节失败都返回 null(未知 ≠ 异常)。
|
|
86
|
+
*/
|
|
87
|
+
export async function fetchZoneHealth({
|
|
88
|
+
zoneId = null,
|
|
89
|
+
baseDomain,
|
|
90
|
+
apiToken,
|
|
91
|
+
fetchImpl = globalThis.fetch,
|
|
92
|
+
apiBase = CF_API_BASE,
|
|
93
|
+
accountId = null,
|
|
94
|
+
} = {}) {
|
|
95
|
+
if (!apiToken || typeof fetchImpl !== 'function') return null;
|
|
96
|
+
let zone = null;
|
|
97
|
+
try {
|
|
98
|
+
if (zoneId) {
|
|
99
|
+
zone = await cfGet(apiBase, apiToken, `/zones/${zoneId}`, fetchImpl);
|
|
100
|
+
}
|
|
101
|
+
// cert 里的 zoneID 可能属于旧 zone(重新接入后会换),名字查一遍更稳
|
|
102
|
+
if (!zone && baseDomain) {
|
|
103
|
+
const list = await cfGet(apiBase, apiToken, `/zones?name=${encodeURIComponent(baseDomain)}`, fetchImpl);
|
|
104
|
+
zone = Array.isArray(list) ? list.find((z) => z && z.name === baseDomain) || null : null;
|
|
105
|
+
}
|
|
106
|
+
} catch {
|
|
107
|
+
return null;
|
|
108
|
+
}
|
|
109
|
+
if (!zone) return null;
|
|
110
|
+
|
|
111
|
+
let accountName = null;
|
|
112
|
+
const acc = accountId || zone.account?.id || null;
|
|
113
|
+
if (acc) {
|
|
114
|
+
try {
|
|
115
|
+
const a = await cfGet(apiBase, apiToken, `/accounts/${acc}`, fetchImpl);
|
|
116
|
+
accountName = a?.name || null;
|
|
117
|
+
} catch {
|
|
118
|
+
/* 只是少一句「账号是谁」,不影响结论 */
|
|
119
|
+
}
|
|
120
|
+
}
|
|
121
|
+
return {
|
|
122
|
+
zoneId: zone.id || null,
|
|
123
|
+
zoneName: zone.name || baseDomain || null,
|
|
124
|
+
status: zone.status || null,
|
|
125
|
+
nameServers: (zone.name_servers || []).map((n) => String(n).toLowerCase().replace(/\.$/, '')).sort(),
|
|
126
|
+
accountId: acc,
|
|
127
|
+
accountName,
|
|
128
|
+
modifiedAt: zone.modified_on || null,
|
|
129
|
+
};
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
const norm = (list) => (Array.isArray(list) ? list : [])
|
|
133
|
+
.map((n) => String(n).toLowerCase().replace(/\.$/, ''))
|
|
134
|
+
.filter(Boolean)
|
|
135
|
+
.sort();
|
|
136
|
+
|
|
137
|
+
/**
|
|
138
|
+
* 把 zone 身份 + 公网 NS 合成为一个诊断码。
|
|
139
|
+
*
|
|
140
|
+
* 判据刻意简单:`moved` 是 Cloudflare 已经明确告诉我们「这域名不归你了」,
|
|
141
|
+
* 优先采信;`active` 时用 NS 交集兜底(NS 刚改完的过渡期两边都可能答话)。
|
|
142
|
+
*/
|
|
143
|
+
export function classifyZone({ zone = null, publicNs = [], dnsOk = false } = {}) {
|
|
144
|
+
const expectedNs = norm(zone?.nameServers);
|
|
145
|
+
const publicNsNorm = norm(publicNs);
|
|
146
|
+
const status = zone?.status || null;
|
|
147
|
+
const base = { status, expectedNs, publicNs: publicNsNorm, zoneName: zone?.zoneName || null, accountName: zone?.accountName || null };
|
|
148
|
+
|
|
149
|
+
if (!zone) return { code: 'unknown', ...base };
|
|
150
|
+
if (status === 'moved') return { code: 'moved', ...base };
|
|
151
|
+
if (status === 'pending' || status === 'initializing') return { code: 'pending', ...base };
|
|
152
|
+
if (status === 'active') {
|
|
153
|
+
const overlap = publicNsNorm.some((n) => expectedNs.includes(n));
|
|
154
|
+
if (publicNsNorm.length && expectedNs.length && !overlap) return { code: 'ns-mismatch', ...base };
|
|
155
|
+
return { code: dnsOk ? 'ok' : 'unresolved', ...base };
|
|
156
|
+
}
|
|
157
|
+
return { code: 'unknown', ...base };
|
|
158
|
+
}
|
|
159
|
+
|
|
160
|
+
/** 诊断码 → 面板短提示(null 表示不必打扰用户)。 */
|
|
161
|
+
export function zoneHint(code) {
|
|
162
|
+
return ZONE_CODE_HINT[code] || null;
|
|
163
|
+
}
|
|
164
|
+
|
|
165
|
+
/**
|
|
166
|
+
* 完整诊断:读证书 → 查 zone → 若给了公网 NS 就一并归类。
|
|
167
|
+
* 任何一步不可用都退回 `{ code: 'unknown' }`,绝不抛。
|
|
168
|
+
*/
|
|
169
|
+
export async function diagnoseZone({
|
|
170
|
+
homeDir = os.homedir(),
|
|
171
|
+
baseDomain,
|
|
172
|
+
publicNs = [],
|
|
173
|
+
dnsOk = false,
|
|
174
|
+
zoneId = null,
|
|
175
|
+
apiToken = null,
|
|
176
|
+
accountId = null,
|
|
177
|
+
fetchImpl = globalThis.fetch,
|
|
178
|
+
apiBase = CF_API_BASE,
|
|
179
|
+
} = {}) {
|
|
180
|
+
const cert = apiToken ? null : readZoneCert({ homeDir });
|
|
181
|
+
const health = await fetchZoneHealth({
|
|
182
|
+
zoneId: zoneId || cert?.zoneId || null,
|
|
183
|
+
accountId: accountId || cert?.accountId || null,
|
|
184
|
+
baseDomain,
|
|
185
|
+
apiToken: apiToken || cert?.apiToken || null,
|
|
186
|
+
fetchImpl,
|
|
187
|
+
apiBase,
|
|
188
|
+
});
|
|
189
|
+
if (!health) return { code: 'unknown', status: null, expectedNs: [], publicNs: norm(publicNs), zoneName: null, accountName: null };
|
|
190
|
+
const verdict = classifyZone({ zone: health, publicNs, dnsOk });
|
|
191
|
+
return {
|
|
192
|
+
...verdict,
|
|
193
|
+
zoneId: health.zoneId,
|
|
194
|
+
accountId: health.accountId,
|
|
195
|
+
modifiedAt: health.modifiedAt,
|
|
196
|
+
};
|
|
197
|
+
}
|
|
198
|
+
|
|
199
|
+
/**
|
|
200
|
+
* 这条 hostname 现在的 CNAME 指向哪条隧道?
|
|
201
|
+
*
|
|
202
|
+
* 用途:多台机器共用一个 Cloudflare 账号时,`cloudflared tunnel route dns
|
|
203
|
+
* --overwrite-dns` 会**静默**把别人的地址抢过来——A 机好好的,B 机一开通 A 机就断,
|
|
204
|
+
* 而且两边面板都显示「成功」。开通前先看一眼归属,能避免这种互相踩踏。
|
|
205
|
+
*
|
|
206
|
+
* @returns {string|null} 小写 CNAME 目标;无记录返回 null;查不到(无凭据/断网)也返回 null
|
|
207
|
+
*/
|
|
208
|
+
export async function findDnsOwner({
|
|
209
|
+
homeDir = os.homedir(),
|
|
210
|
+
baseDomain,
|
|
211
|
+
hostname,
|
|
212
|
+
fetchImpl = globalThis.fetch,
|
|
213
|
+
apiBase = CF_API_BASE,
|
|
214
|
+
zoneId = null,
|
|
215
|
+
apiToken = null,
|
|
216
|
+
} = {}) {
|
|
217
|
+
const cert = apiToken ? null : readZoneCert({ homeDir });
|
|
218
|
+
const token = apiToken || cert?.apiToken || null;
|
|
219
|
+
if (!token || !hostname) return null;
|
|
220
|
+
try {
|
|
221
|
+
let zid = zoneId || null;
|
|
222
|
+
if (!zid && baseDomain) {
|
|
223
|
+
const list = await cfGet(apiBase, token, `/zones?name=${encodeURIComponent(baseDomain)}`, fetchImpl);
|
|
224
|
+
zid = Array.isArray(list) ? list.find((z) => z && z.name === baseDomain)?.id || null : null;
|
|
225
|
+
}
|
|
226
|
+
if (!zid) return null;
|
|
227
|
+
const records = await cfGet(
|
|
228
|
+
apiBase,
|
|
229
|
+
token,
|
|
230
|
+
`/zones/${zid}/dns_records?type=CNAME&name=${encodeURIComponent(hostname)}`,
|
|
231
|
+
fetchImpl,
|
|
232
|
+
);
|
|
233
|
+
const hit = Array.isArray(records) ? records[0] : null;
|
|
234
|
+
return hit?.content ? String(hit.content).toLowerCase().replace(/\.$/, '') : null;
|
|
235
|
+
} catch {
|
|
236
|
+
return null;
|
|
237
|
+
}
|
|
238
|
+
}
|
|
239
|
+
|
|
240
|
+
/** 这条 CNAME 目标是不是"本机隧道":只比较 UUID 前缀,容忍 cfdargotunnel.com 结尾差异。 */
|
|
241
|
+
export function cnameBelongsTo(content, tunnelId) {
|
|
242
|
+
if (!content || !tunnelId) return false;
|
|
243
|
+
return String(content).toLowerCase().startsWith(String(tunnelId).toLowerCase());
|
|
244
|
+
}
|
|
245
|
+
|
|
246
|
+
/** 稳定摘要,用于把「同一份 zone」与「另一份 zone」区分开(不写 ID,只做等值比较)。 */
|
|
247
|
+
export function zoneFingerprint(zone) {
|
|
248
|
+
const src = `${zone?.accountId || ''}|${zone?.zoneId || ''}|${zone?.zoneName || ''}`;
|
|
249
|
+
if (!src.replace(/\|/g, '')) return null;
|
|
250
|
+
return crypto.createHash('sha256').update(src).digest('hex').slice(0, 12);
|
|
251
|
+
}
|