@wkgeo/cli 1.1.5 → 2.0.0

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.
@@ -1083,7 +1083,7 @@ export const templatePublishCommand = {
1083
1083
  'wkgeo template publish --dir ./tpl/demo --key t144-probe --confirm # 真写(测试 key)',
1084
1084
  ],
1085
1085
  notes: [
1086
- '凭据只从 env / 本机 `oss.env` / `tencent/cloudbase/.env` 读,**永不打印**(只报"已配置 + 来源路径 + 末 4 位")。',
1086
+ '凭据只从 env / 本机 `oss.env` 读,**永不打印**(只报"已配置 + 来源路径 + 末 4 位");数据库读写走真库 RDS 通道(腾讯 CloudBase 旧网关已退役)。',
1087
1087
  '真写前先把**市场行 + OSS 前缀清单**存档到 `.tmp-build/t144/`(`--archive` 可改),写完再存一份,前后可比。',
1088
1088
  'OSS 走手写 V1 签名(CLI 零依赖,不引 ali-oss);`prefix`/`max-keys` 这类普通查询参数**不进签名**,进了会 SignatureDoesNotMatch。',
1089
1089
  '顺序:上传 → prune(新替旧)→ upsert 市场行(`version` 自增、`sha256` = 发布清单摘要)→ 回读(行 / files 数 / OSS HEAD / 对象直链 / 预览短链)。',
@@ -112,22 +112,8 @@ export function resolveOssCreds({ cwd = process.cwd(), env = process.env } = {})
112
112
  };
113
113
  }
114
114
 
115
- /**
116
- * 解析数据库凭据:env 优先,其次 `tencent/cloudbase/.env`(沿 cwd 向上找)。
117
- */
118
- export function resolveDbCreds({ cwd = process.cwd(), env = process.env } = {}) {
119
- const explicit = env.WKGEO_CLOUDBASE_ENV;
120
- const root = explicit && fs.existsSync(explicit) ? explicit : findUp(cwd, path.join('tencent', 'cloudbase', '.env'));
121
- const file = explicit && fs.existsSync(explicit) ? path.resolve(explicit) : root ? path.join(root, 'tencent', 'cloudbase', '.env') : null;
122
- const vars = file ? parseEnvFile(file) : {};
123
- const pick = (k) => env[k] || vars[k] || '';
124
- return {
125
- envId: pick('CLOUDBASE_ENV_ID'),
126
- apiKey: pick('CLOUDBASE_APIKEY'),
127
- source: file,
128
- gateway: pick('CLOUDBASE_GATEWAY'),
129
- };
130
- }
115
+ /* 数据库凭据:2026-11-18 task-973 —— 腾讯 CloudBase `exec-pgsql` + `CLOUDBASE_APIKEY` 已退役,
116
+ * 不再解析 / 不再要求;写市场行走真库 RDS 通道(见下面 `dbExec`)。 */
131
117
 
132
118
  /** 只报"有没有配",不报值 */
133
119
  export function credsSummary(creds) {
@@ -139,12 +125,6 @@ export function credsSummary(creds) {
139
125
  source: creds.oss.source,
140
126
  access_key_id_tail: creds.oss.accessKeyId ? creds.oss.accessKeyId.slice(-4) : '',
141
127
  },
142
- db: {
143
- configured: !!(creds.db.envId && creds.db.apiKey),
144
- env_id: creds.db.envId,
145
- source: creds.db.source,
146
- api_key_tail: creds.db.apiKey ? creds.db.apiKey.slice(-4) : '',
147
- },
148
128
  };
149
129
  }
150
130
 
@@ -241,65 +221,56 @@ export function ossPublicUrl({ creds, objectKey }) {
241
221
  return `https://${creds.bucket}.${creds.region}.aliyuncs.com/${objectKey}`;
242
222
  }
243
223
 
244
- /* ------------------------------------------------------------------ 数据库(CloudBase PG 网关,只读/写都走它) */
224
+ /* ------------------------------------------------------------------ 数据库(真库 RDS) */
225
+
226
+ /** 懒加载真库通道:`deploy-web/_lib/pg-rds.mjs` 不在 npm 包里 ⇒ 只在真正要读写市场行时才解析。 */
227
+ let rdsModPromise = null;
228
+ function loadRds() {
229
+ if (!rdsModPromise) {
230
+ rdsModPromise = import(new URL('../../deploy-web/_lib/pg-rds.mjs', import.meta.url).href).catch((e) => {
231
+ rdsModPromise = null;
232
+ throw new CliError('数据库通道不可用(真库 RDS 探针仅仓库内可用)', {
233
+ kind: 'db',
234
+ code: 'EDB',
235
+ hint: String((e && e.message) || e).slice(0, 300),
236
+ });
237
+ });
238
+ }
239
+ return rdsModPromise;
240
+ }
245
241
 
246
242
  /**
247
- * 执行一条 PG 语句。
248
- * 通道与 `.tmp-build/qbk/pg.mjs` 相同:POST `<gateway>/v1/rdb/exec-pgsql`
249
- * body `{sql, parameters, role:'cloudbase_postgres'}`,响应取 `data ?? rows ?? 自身`。
243
+ * 执行一条 PG 语句(2026-11-18 task-973:腾讯 CloudBase `exec-pgsql` 网关已退役,改走真库 RDS)。
244
+ * `rdsExec` 返回行对象数组(与旧网关形状一致);只读语句不给 `write`,写语句显式 `write:true`。
250
245
  */
251
- export async function dbExec({ creds, sql, parameters = [], fetchImpl = fetch }) {
252
- const host = creds.gateway || `https://${creds.envId}.api.tcloudbasegateway.com`;
253
- const res = await fetchImpl(`${host.replace(/\/$/, '')}/v1/rdb/exec-pgsql`, {
254
- method: 'POST',
255
- headers: { 'content-type': 'application/json', authorization: `Bearer ${creds.apiKey}` },
256
- body: JSON.stringify({ sql, parameters, role: 'cloudbase_postgres' }),
257
- });
258
- const text = await res.text();
259
- let json = null;
260
- try {
261
- json = JSON.parse(text);
262
- } catch {
263
- json = null;
264
- }
265
- if (!res.ok) {
266
- throw new CliError(`数据库请求失败 ${res.status}`, {
267
- kind: 'db',
268
- code: 'EDB',
269
- hint: (text || '').slice(0, 300),
270
- });
271
- }
272
- const data = json && (json.data ?? json.rows ?? json.result ?? json);
273
- const rows = Array.isArray(data) ? data : data && Array.isArray(data.rows) ? data.rows : [];
274
- return { rows, raw: json };
246
+ export async function dbExec({ sql, parameters = [], write = false } = {}) {
247
+ const mod = await loadRds();
248
+ const rows = await mod.rdsExec(sql, parameters, write ? { write: true } : undefined);
249
+ return { rows, raw: rows };
275
250
  }
276
251
 
277
252
  /** 读一行市场模板(不存在返回 null) */
278
- export async function readMarketRow({ creds, key, fetchImpl = fetch }) {
253
+ export async function readMarketRow({ key } = {}) {
279
254
  const { rows } = await dbExec({
280
- creds,
281
255
  sql: `select id::text as id, key, name, sort, price_cents, coalesce(version, 0) as version, sha256, jsonb_array_length(files) as files_count, enabled, updated_at::text as updated_at from ${MARKET_TABLE} where key = $1 limit 1`,
282
256
  parameters: [key],
283
- fetchImpl,
284
257
  });
285
258
  return rows[0] || null;
286
259
  }
287
260
 
288
261
  /** 删一行市场模板(清理测试用;调用方负责确认 key) */
289
- export async function deleteMarketRow({ creds, key, fetchImpl = fetch }) {
262
+ export async function deleteMarketRow({ key } = {}) {
290
263
  const { rows } = await dbExec({
291
- creds,
292
264
  sql: `delete from ${MARKET_TABLE} where key = $1 returning id::text as id, key`,
293
265
  parameters: [key],
294
- fetchImpl,
266
+ write: true,
295
267
  });
296
268
  return rows[0] || null;
297
269
  }
298
270
 
299
271
  /** upsert:`files` 就是这个 key 的完整清单(覆盖写),`version` 自增 */
300
- export async function upsertMarketRow({ creds, row, fetchImpl = fetch }) {
272
+ export async function upsertMarketRow({ row } = {}) {
301
273
  const { rows } = await dbExec({
302
- creds,
303
274
  sql: `insert into ${MARKET_TABLE}
304
275
  (key, name, summary, files, sort, enabled, price_cents, demo, industries, visible_scope, requires_plugins, version, sha256)
305
276
  values ($1, $2, $3, $4::jsonb, $5, true, $6, $7::jsonb, $8::jsonb, 'all', '[]'::jsonb, 1, $9)
@@ -327,7 +298,7 @@ returning id::text as id, key, name, sort, price_cents, coalesce(version, 0) as
327
298
  JSON.stringify(row.industries || []),
328
299
  row.sha256,
329
300
  ],
330
- fetchImpl,
301
+ write: true,
331
302
  });
332
303
  return rows[0] || null;
333
304
  }
@@ -498,7 +469,7 @@ export async function publishTemplate({
498
469
  onStep = () => {},
499
470
  } = {}) {
500
471
  const collected = await collectTemplate({ dir, key });
501
- const resolved = creds || { oss: resolveOssCreds({ cwd }), db: resolveDbCreds({ cwd }) };
472
+ const resolved = creds || { oss: resolveOssCreds({ cwd }) };
502
473
  if (!resolved.oss.accessKeyId || !resolved.oss.accessKeySecret) {
503
474
  throw new CliError('OSS 凭据缺失(OSS_ACCESS_KEY_ID / OSS_ACCESS_KEY_SECRET)', {
504
475
  kind: 'usage',
@@ -507,21 +478,12 @@ export async function publishTemplate({
507
478
  hint: '写到 oss.env(仓库根)或设进环境变量;本命令不打印任何密钥',
508
479
  });
509
480
  }
510
- if (!resolved.db.envId || !resolved.db.apiKey) {
511
- throw new CliError('数据库凭据缺失(CLOUDBASE_ENV_ID / CLOUDBASE_APIKEY)', {
512
- kind: 'usage',
513
- code: 'ENOCREDS',
514
- exitCode: 2,
515
- hint: '写到 tencent/cloudbase/.env 或设进环境变量',
516
- });
517
- }
518
481
  const ossCreds = {
519
482
  accessKeyId: resolved.oss.accessKeyId,
520
483
  accessKeySecret: resolved.oss.accessKeySecret,
521
484
  bucket: resolved.oss.bucket,
522
485
  region: resolved.oss.region,
523
486
  };
524
- const dbCreds = { envId: resolved.db.envId, apiKey: resolved.db.apiKey, gateway: resolved.db.gateway };
525
487
  const paths = archivePaths(archiveDir, collected.key);
526
488
  const steps = [];
527
489
  const step = (name, status, detail = null) => {
@@ -533,7 +495,7 @@ export async function publishTemplate({
533
495
 
534
496
  // ① 读目录 + 计划(含现有市场行 / OSS 清单 = "前"存档)
535
497
  step('collect', 'ok', { files: collected.files.length, bytes: collected.totalBytes, problems: collected.problems.length });
536
- const marketBefore = await readMarketRow({ creds: dbCreds, key: collected.key, fetchImpl });
498
+ const marketBefore = await readMarketRow({ key: collected.key });
537
499
  const ossBefore = await ossList({ creds: ossCreds, prefix: `templates/${collected.key}/`, fetchImpl });
538
500
  step('archive-before', 'ok', { market: !!marketBefore, oss_objects: ossBefore.keys.length });
539
501
  const plan = buildPlan({
@@ -596,7 +558,6 @@ export async function publishTemplate({
596
558
 
597
559
  // ④ upsert 市场行(files 顺序 = template.json.files 顺序)
598
560
  const row = await upsertMarketRow({
599
- creds: dbCreds,
600
561
  row: {
601
562
  key: collected.key,
602
563
  name: collected.name,
@@ -608,12 +569,11 @@ export async function publishTemplate({
608
569
  industries: collected.industries,
609
570
  sha256: collected.digest,
610
571
  },
611
- fetchImpl,
612
572
  });
613
573
  step('market-upsert', 'ok', row);
614
574
 
615
575
  // ⑤ 回读校验
616
- const marketAfter = await readMarketRow({ creds: dbCreds, key: collected.key, fetchImpl });
576
+ const marketAfter = await readMarketRow({ key: collected.key });
617
577
  const ossAfter = await ossList({ creds: ossCreds, prefix: `templates/${collected.key}/`, fetchImpl });
618
578
  const heads = [];
619
579
  for (const up of plan.uploads) {
@@ -699,18 +659,17 @@ export async function cleanupTemplate({ key, creds = null, cwd = process.cwd(),
699
659
  if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(String(key || ''))) {
700
660
  throw new CliError(`非法 key:${key}`, { kind: 'usage', code: 'EBADKEY', exitCode: 2 });
701
661
  }
702
- const resolved = creds || { oss: resolveOssCreds({ cwd }), db: resolveDbCreds({ cwd }) };
662
+ const resolved = creds || { oss: resolveOssCreds({ cwd }) };
703
663
  const ossCreds = resolved.oss;
704
- const dbCreds = resolved.db;
705
664
  const before = await ossList({ creds: ossCreds, prefix: `templates/${key}/`, fetchImpl });
706
665
  const removed = [];
707
666
  for (const obj of before.keys) {
708
667
  const r = await ossDelete({ creds: ossCreds, objectKey: obj.key, fetchImpl });
709
668
  if (r.ok) removed.push(obj.key);
710
669
  }
711
- const row = await deleteMarketRow({ creds: dbCreds, key, fetchImpl });
670
+ const row = await deleteMarketRow({ key });
712
671
  const after = await ossList({ creds: ossCreds, prefix: `templates/${key}/`, fetchImpl });
713
- const rowAfter = await readMarketRow({ creds: dbCreds, key, fetchImpl });
672
+ const rowAfter = await readMarketRow({ key });
714
673
  return { key, removed, row, oss_before: before.keys.length, oss_after: after.keys.length, market_before: !!row, market_after: !!rowAfter };
715
674
  }
716
675
 
@@ -720,7 +679,6 @@ export default {
720
679
  buildPlan,
721
680
  cleanupTemplate,
722
681
  resolveOssCreds,
723
- resolveDbCreds,
724
682
  credsSummary,
725
683
  ossPut,
726
684
  ossHead,
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@wkgeo/cli",
3
- "version": "1.1.5",
3
+ "version": "2.0.0",
4
4
  "description": "云站平台官方命令行客户端(@wkgeo/cli):授权登录一次,之后建站 / 下单 / 钱包支付 / 查余额都不用再登录(OAuth 授权码 + PKCE,公共客户端,零第三方依赖)",
5
5
  "keywords": [
6
6
  "wkgeo",
@@ -1,428 +0,0 @@
1
- /**
2
- * 域名级 DNS 凭据(2026-10-28 老板单):`domain dns credential detect|set|status|delete`
3
- *
4
- * ## 这是什么
5
- * 客户买了平台域名(或自带域名)之后,**要不要能自动加解析**取决于该域名当前 NS 指向谁
6
- * (注册商 ≠ DNS 托管商)。这组命令让客户给「DNS 托管商」配一把 AK:
7
- * 配了 ⇒ 发布/开通链路可以自动加解析;没配 ⇒ 回 `dns_credential_missing` 走人工兜底。
8
- *
9
- * ## 为什么命令名是四词(`domain dns credential set`)
10
- * 既有 `domain dns`(siteops)讲的是"照抄表:你该去别处加哪几条解析",`domain zone …` 是
11
- * 真的动平台账号里的云解析 —— 两者都占着 `domain dns` / `domain zone` 前缀。本组是**客户自己的**
12
- * DNS 托管商凭据,语义第三类,所以占 `domain dns credential` 这一段。
13
- * `cli/lib/args.mjs#resolveCommand` 支持到四词(最长前缀匹配:4 → 3 → 2 → 1)。
14
- *
15
- * ## 安全口径(本单是 auth/密钥类,一票否决)
16
- * · **AK Secret 永远不进命令行**(shell history / ps / CI 日志都会留);只从
17
- * **stdin 管道**(`--stdin` 或非 TTY 自动)或**无回显交互**读;
18
- * · 服务端用 AES-256-GCM 加密落库(主密钥只在云函数 env `DOMAIN_CRED_ENC_KEY`),
19
- * 本 CLI **从不打印** secret,只打印 `ak_id` 前 4 位;
20
- * · `set` 是"先验证后落库":服务商 API 不通 / 权限不够 ⇒ 服务端 400 且**不落库**;
21
- * · `status` / `detect` 的响应结构里**没有 secret 字段**(服务端白名单出参)。
22
- */
23
-
24
- import readline from 'node:readline';
25
-
26
- import { UsageError, CliError } from '../errors.mjs';
27
-
28
- /** 服务端还没发版时,把"未知动作"翻译成"服务端缺口",别让人以为命令用错了 */
29
- function isActionNotDeployed(err) {
30
- const msg = String((err && err.message) || '');
31
- return /未知动作|未知操作|未在权限表中登记|Unknown action/i.test(msg);
32
- }
33
-
34
- async function callOps(ctx, action, payload, what) {
35
- try {
36
- return await ctx.callData(action, payload);
37
- } catch (e) {
38
- if (isActionNotDeployed(e)) {
39
- throw new CliError(`服务端尚未部署「${what}」(${action})`, {
40
- kind: 'not_deployed',
41
- code: e.code,
42
- hint: '这是服务端缺口(wkgeo-cli-fc 未发版),不是命令用错了',
43
- raw: e.raw,
44
- });
45
- }
46
- throw e;
47
- }
48
- }
49
-
50
- /**
51
- * 服务端错误体(`failWithData` 的 data 段);拿不到就返回空对象。
52
- * 分层顺序:`err.raw.body.data`(api.mjs 的 raw 形状)→ `err.data` → `err.raw.body`。
53
- * 为什么要这么绕:项目信封是 HTTP 恒 200 + `body.code` 表成败,业务细节在 `body.data` 里。
54
- */
55
- function errorBody(err) {
56
- const raw = (err && err.raw) || null;
57
- const pick = (o) => (o && typeof o === 'object' && !Array.isArray(o) ? o : null);
58
- const candidates = [
59
- pick(raw && raw.body && raw.body.data),
60
- pick(err && err.data),
61
- pick(raw && raw.data),
62
- pick(raw && raw.body),
63
- pick(raw),
64
- ];
65
- for (const one of candidates) if (one) return one;
66
- return {};
67
- }
68
-
69
- const PROVIDER_LABELS = {
70
- aliyun: '阿里云云解析(Alidns)',
71
- tencent: '腾讯云 DNSPod',
72
- cloudflare: 'Cloudflare',
73
- huawei: '华为云 DNS',
74
- baidu: '百度云 DNS',
75
- 'dnspod-intl': 'DNSPod 国际版',
76
- };
77
-
78
- const labelOf = (p) => PROVIDER_LABELS[p] || p || '—';
79
-
80
- /** `--extra '{"line":"默认"}'` 或 `--extra k=v --extra k2=v2`(两种都收,后者更好打) */
81
- function parseExtra(raw) {
82
- const list = Array.isArray(raw) ? raw : raw === undefined || raw === null || raw === '' ? [] : [raw];
83
- const out = {};
84
- for (const one of list) {
85
- const s = String(one || '').trim();
86
- if (!s) continue;
87
- if (s.startsWith('{')) {
88
- let obj = null;
89
- try {
90
- obj = JSON.parse(s);
91
- } catch {
92
- throw new UsageError(`--extra 不是合法 JSON:${s.slice(0, 60)}`);
93
- }
94
- if (!obj || typeof obj !== 'object' || Array.isArray(obj)) {
95
- throw new UsageError('--extra 必须是 JSON 对象,例如:--extra \'{"host":"alidns"}\'');
96
- }
97
- Object.assign(out, obj);
98
- continue;
99
- }
100
- const eq = s.indexOf('=');
101
- if (eq <= 0) throw new UsageError(`--extra 写法:k=v 或 JSON 对象,收到:${s.slice(0, 40)}`);
102
- const k = s.slice(0, eq).trim();
103
- const v = s.slice(eq + 1).trim();
104
- if (/secret|password|token|key/i.test(k)) {
105
- throw new UsageError(`--extra 里不要放密钥(${k}):extras 会原文落库,密钥请走 AK Secret 通道`);
106
- }
107
- out[k] = v;
108
- }
109
- return Object.keys(out).length ? out : undefined;
110
- }
111
-
112
- /* ------------------------------ 读 secret ------------------------------ */
113
-
114
- /** 从 stdin 读完(管道 / 重定向 / CI),取第一行非空内容 */
115
- function readStdinAll(stdin) {
116
- return new Promise((resolve, reject) => {
117
- let buf = '';
118
- try {
119
- stdin.setEncoding('utf8');
120
- } catch {
121
- /* 有些注入的假 stdin 没有 setEncoding,忽略 */
122
- }
123
- stdin.on('data', (chunk) => {
124
- buf += String(chunk);
125
- });
126
- stdin.once('end', () => resolve(buf));
127
- stdin.once('error', reject);
128
- if (typeof stdin.resume === 'function') stdin.resume();
129
- });
130
- }
131
-
132
- /**
133
- * 交互读 secret:**不回显**(`_writeToOutput` 静音,提示语我们自己先打出去)。
134
- * 为什么不用 `ctx.ask`:那是带回显的行输入,密钥会明晃晃留在屏幕上(旁边有人就废了)。
135
- */
136
- function promptHidden(question, { stdin = process.stdin, stdout = process.stdout } = {}) {
137
- return new Promise((resolve, reject) => {
138
- stdout.write(question);
139
- const rl = readline.createInterface({ input: stdin, output: stdout, terminal: true });
140
- // 静音:readline 自己的提示语与键入字符都不写出去(提示语已由上面 stdout.write 打出)
141
- rl._writeToOutput = () => {};
142
- rl.question('', (answer) => {
143
- stdout.write('\n');
144
- rl.close();
145
- resolve(String(answer || '').trim());
146
- });
147
- rl.on('error', reject);
148
- });
149
- }
150
-
151
- /**
152
- * secret 的三个来源(按优先级):
153
- * 1. `--stdin`:强制从 stdin 读(脚本里显式写清楚更安全);
154
- * 2. stdin 不是 TTY(管道 / 重定向):自动从 stdin 读;
155
- * 3. TTY:无回显交互输入。
156
- */
157
- async function readSecret(ctx, flags) {
158
- const stdin = ctx.stdin || process.stdin;
159
- const piped = flags.stdin === true || !ctx.stdinIsTTY;
160
- if (piped) {
161
- const text = await readStdinAll(stdin);
162
- const line = text
163
- .split(/\r?\n/)
164
- .map((s) => s.trim())
165
- .find((s) => s.length > 0);
166
- if (!line) {
167
- throw new UsageError(
168
- '没从 stdin 读到 AK Secret。管道用法(**不要**写进命令行):\n' +
169
- ' printf %s "$DNS_AK_SECRET" | wkgeo domain dns credential set example.com --provider aliyun --ak-id LTAI... --stdin',
170
- );
171
- }
172
- return line;
173
- }
174
- const answer = await promptHidden('AK Secret(输入不回显,粘贴后按回车):', { stdin, stdout: process.stdout });
175
- if (!answer) throw new UsageError('没输入 AK Secret(已取消)');
176
- return answer;
177
- }
178
-
179
- /* ------------------------------ 动作 1:detect ------------------------------ */
180
-
181
- export const dnsCredentialDetectCommand = {
182
- name: 'domain dns credential detect',
183
- summary: '只看 NS:域名现在托管在哪家 DNS、能不能自动加解析(只读,不落库)',
184
- usage: 'wkgeo domain dns credential detect <域名> [--json]',
185
- args: [{ name: 'domain', required: true, desc: '要探测的域名(不带 www)' }],
186
- examples: [
187
- 'wkgeo domain dns credential detect example.com',
188
- 'wkgeo domain dns credential detect example.com --json',
189
- ],
190
- notes: [
191
- 'NS 是**公共信息**;凭据段(有没有配、配的哪家、AK 前 4 位)只有域名归属人看得到。',
192
- '推断只做预填:注册商 ≠ DNS 托管商,最终以 `--provider` 显式选择为准。',
193
- ],
194
- async run(ctx) {
195
- const { out, positional } = ctx;
196
- const domain = String(positional.domain || '').trim();
197
- if (!domain) throw new UsageError('用法:wkgeo domain dns credential detect <域名>');
198
- const data = (await callOps(ctx, 'dnsCredentialDetect', { domain }, 'DNS 凭据探测')) || {};
199
-
200
- if (!out.json) {
201
- out.head(`DNS 探测:${data.domain || domain}`);
202
- const ns = Array.isArray(data.nameservers) ? data.nameservers : [];
203
- out.table(
204
- [{ title: 'NS', key: 'ns', width: 46 }],
205
- ns.map((one) => ({ ns: one })),
206
- );
207
- if (!ns.length) out.warn('查不到 NS(域名可能还没解析 / 公共 DNS 查询失败)');
208
- out.info(` 推断托管商:${labelOf(data.inferred_provider)}` + (data.inferred_provider ? '' : '(无法判断)'));
209
- if (data.ns_mixed) out.warn('NS 来自多家(可能正在切托管商,别急着配)');
210
- const cred = data.credential || null;
211
- if (data.credential_hidden) {
212
- out.info(' 这个域名不是你的:凭据信息已隐藏(NS 是公共信息,照常显示)');
213
- } else if (cred && cred.configured) {
214
- out.ok(
215
- `已配凭据:${labelOf(cred.dns_provider)},AK ${cred.ak_id_prefix || '—'}****,` +
216
- `验证时间 ${cred.verified_at || '—'}${cred.enabled === false ? ',**已停用**' : ''}`,
217
- );
218
- if (cred.ns_mismatch) out.warn(`已配的托管商(${cred.dns_provider})与当前 NS 推断(${data.inferred_provider || '未知'})不一致`);
219
- } else {
220
- out.info(' 这个域名还没配 DNS 凭据 ⇒ 发布/开通时解析会自动加不了,回 dns_credential_missing');
221
- }
222
- if (data.suggested) out.info(` 建议动作:${data.suggested}`);
223
- if (Array.isArray(data.not_integrated) && data.not_integrated.length) {
224
- out.info(` 暂未接入自动解析:${data.not_integrated.map((one) => (one.label || one.provider || one)).join(' / ')}`);
225
- }
226
- }
227
- ctx.done(data);
228
- return data;
229
- },
230
- };
231
-
232
- /* ------------------------------ 动作 2:set ------------------------------ */
233
-
234
- export const dnsCredentialSetCommand = {
235
- name: 'domain dns credential set',
236
- summary: '给域名配一把 DNS 托管商 AK(先调 API 验证,通过才落库;secret 只从 stdin/交互读)',
237
- usage:
238
- 'wkgeo domain dns credential set <域名> --ak-id <AK ID> [--provider aliyun|tencent] [--extra k=v] [--stdin]',
239
- args: [{ name: 'domain', required: true, desc: '要配凭据的域名(必须是你的、来源 customer_own)' }],
240
- flags: {
241
- provider: { type: 'string', desc: 'DNS 托管商(aliyun / tencent;不填会按 NS 给建议并要求确认)' },
242
- 'ak-id': { type: 'string', desc: 'AK ID(不是密钥,可以写在命令行)' },
243
- extra: { type: 'string', desc: '服务商差异参数:`k=v`(可重复)或 JSON 对象,如 line=默认 / host=alidns' },
244
- stdin: { type: 'boolean', desc: '从 stdin 读 AK Secret(管道;非 TTY 下默认就是它)' },
245
- },
246
- examples: [
247
- 'printf %s "$DNS_AK_SECRET" | wkgeo domain dns credential set example.com --provider aliyun --ak-id LTAI5tXXXX --stdin',
248
- 'wkgeo domain dns credential set example.com --provider tencent --ak-id AKIDxxxx # 交互输入 secret(不回显)',
249
- 'wkgeo domain dns credential set example.com --ak-id LTAI5tXXXX --provider aliyun --extra line=默认',
250
- ],
251
- notes: [
252
- '**AK Secret 不要写进命令行**:那会进 shell history / 进程列表 / CI 日志。只走 stdin 或交互输入。',
253
- '服务端用 AES-256-GCM 加密落库(主密钥只在云函数 env),之后任何读接口都不会回传 secret。',
254
- '不填 `--provider` 时服务端**不猜**:返回当前 NS 列表 + 推断托管商,请确认后用 `--provider` 再提交。',
255
- '配的最小权限只需「解析记录读写」:阿里云 RAM 限 Alidns 的 Describe/Add/Update/DeleteDomainRecords;腾讯云 CAM 限 DNSPod 的 Record 读写。',
256
- ],
257
- async run(ctx) {
258
- const { out, flags, positional } = ctx;
259
- const domain = String(positional.domain || '').trim();
260
- if (!domain) {
261
- throw new UsageError(
262
- '用法:printf %s "$SECRET" | wkgeo domain dns credential set <域名> --provider aliyun --ak-id <AK ID> --stdin',
263
- );
264
- }
265
- const akId = String(flags.akId || '').trim();
266
- if (!akId) throw new UsageError('缺少 --ak-id(AK ID 不是密钥,可以写在命令行)');
267
- const provider = String(flags.provider || '').trim().toLowerCase();
268
- const extra = parseExtra(flags.extra);
269
-
270
- if (!out.json) {
271
- out.notice('· AK Secret 只从 stdin / 无回显交互读,不进 shell history;服务端加密落库后不再回显。');
272
- }
273
- const akSecret = await readSecret(ctx, flags);
274
-
275
- const payload = { domain, akId, akSecret };
276
- if (provider) payload.dnsProvider = provider;
277
- if (extra) payload.extra = extra;
278
-
279
- let data = null;
280
- try {
281
- data = (await callOps(ctx, 'dnsCredentialSet', payload, '配置 DNS 凭据')) || {};
282
- } catch (e) {
283
- const body = errorBody(e);
284
- const code = String(body.code || '');
285
- /* 缺 provider:把 NS 建议摊开,要求显式确认(这条是产品语义,不是报错文案) */
286
- if (code === 'dns_provider_required') {
287
- const ns = Array.isArray(body.nameservers) ? body.nameservers : [];
288
- if (!out.json) {
289
- out.head(`还不能保存:${domain} 的 DNS 托管商没说清楚`);
290
- out.table([{ title: 'NS', key: 'ns', width: 46 }], ns.map((one) => ({ ns: one })));
291
- out.info(` 按 NS 推断:${labelOf(body.inferred_provider)}` + (body.hint ? `(${body.hint})` : ''));
292
- out.info(' 注册商 ≠ DNS 托管商:请确认托管商后重跑,并显式给出 --provider');
293
- out.info(` 例:printf %s "$SECRET" | wkgeo domain dns credential set ${domain} --provider ${body.inferred_provider || '<aliyun|tencent>'} --ak-id <AK ID> --stdin`);
294
- }
295
- throw new CliError(`缺少 dnsProvider(推断为 ${body.inferred_provider || '未知'},需确认)`, {
296
- kind: 'needs_confirmation',
297
- code: e.code,
298
- hint: `确认托管商后加 --provider ${body.inferred_provider || '<aliyun|tencent>'}`,
299
- raw: e.raw,
300
- });
301
- }
302
- /* 验证失败:服务商的验证结论是"人话原因",这里补一句下一步 */
303
- if (code === 'dns_credential_verify_failed') {
304
- throw new CliError(String((e && e.message) || '验证失败'), {
305
- kind: 'verify_failed',
306
- code: e.code,
307
- hint: body.next || '检查 AK 是否属于该 DNS 托管商、是否被停用、最小权限是否给够(只读解析列表即可)',
308
- raw: e.raw,
309
- });
310
- }
311
- throw e;
312
- }
313
-
314
- if (!out.json) {
315
- out.head(`已保存 DNS 凭据:${data.domain || domain}`);
316
- out.ok(`托管商:${labelOf(data.dns_provider)}(API 验证通过,verified_at=${data.verified_at || '—'})`);
317
- out.ok(`AK:${data.ak_id_prefix || akId.slice(0, 4)}****(secret 已加密落库:${data.secret_storage || 'aes-256-gcm'},不会再回显)`);
318
- if (data.ns_mismatch) {
319
- out.warn(
320
- `NS 不一致:当前 NS 看起来不是 ${labelOf(data.dns_provider)}(推断 ${labelOf(data.detected_provider)})。` +
321
- '已按你的选择保存;等 NS 切过来后 `detect` 会一致,发布链路以你选的托管商为准。',
322
- );
323
- }
324
- if (data.warning) out.warn(data.warning);
325
- out.info(' 下一步:wkgeo domain dns credential status ' + (data.domain || domain));
326
- }
327
- ctx.done(data);
328
- return data;
329
- },
330
- };
331
-
332
- /* ------------------------------ 动作 3:status ------------------------------ */
333
-
334
- export const dnsCredentialStatusCommand = {
335
- name: 'domain dns credential status',
336
- summary: '看这个域名的 DNS 凭据状态(有没有配 / 是否验证过 / 是否停用;**永不回传 secret**)',
337
- usage: 'wkgeo domain dns credential status <域名> [--json]',
338
- args: [{ name: 'domain', required: true, desc: '要查的域名' }],
339
- examples: ['wkgeo domain dns credential status example.com'],
340
- notes: [
341
- '`state` 三态:configured(可自动加解析)/ missing(没配 ⇒ 链路降级 dns_credential_missing)/ disabled(连续失败被停用)。',
342
- '出参是服务端白名单(`safeView`):结构上**没有** secret / 密文字段。',
343
- ],
344
- async run(ctx) {
345
- const { out, positional } = ctx;
346
- const domain = String(positional.domain || '').trim();
347
- if (!domain) throw new UsageError('用法:wkgeo domain dns credential status <域名>');
348
- const data = (await callOps(ctx, 'dnsCredentialStatus', { domain }, 'DNS 凭据状态')) || {};
349
-
350
- if (!out.json) {
351
- out.head(`DNS 凭据状态:${data.domain || domain}`);
352
- const stateText =
353
- data.state === 'configured'
354
- ? data.enabled === false
355
- ? 'disabled(已停用)'
356
- : 'configured(可自动加解析)'
357
- : data.state === 'disabled'
358
- ? 'disabled(连续失败被停用)'
359
- : 'missing(没配 ⇒ 解析降级人工兜底)';
360
- out.line(` 状态:${stateText}`);
361
- if (data.degraded) out.warn(`降级:${data.reason || '凭据库不可用'}(按 missing 处理,不 500)`);
362
- if (data.configured) {
363
- out.table(
364
- [
365
- { title: '项', key: 'k', width: 18 },
366
- { title: '值', key: 'v', width: 52 },
367
- ],
368
- [
369
- { k: 'DNS 托管商', v: `${labelOf(data.dns_provider)}(${data.dns_provider || '—'})` },
370
- { k: 'AK', v: `${data.ak_id_prefix || '—'}****` },
371
- { k: '已验证', v: String(data.verified_at || '—') },
372
- { k: 'NS 推断', v: labelOf(data.detected_provider) },
373
- { k: 'NS 不一致', v: data.ns_mismatch ? '是(客户可能正在切 NS)' : '否' },
374
- { k: '启用', v: data.enabled ? '是' : '否' },
375
- { k: '连续失败', v: String(data.consecutive_failures || 0) },
376
- { k: '最近错误', v: String(data.last_error || '—').slice(0, 60) },
377
- ],
378
- );
379
- if (data.enabled === false) {
380
- out.warn('已停用:自动加解析不会再用这把 key;修好权限后重新 `set` 或人工处理');
381
- }
382
- } else {
383
- out.info(' 没配或已删除 ⇒ 发布/开通链路会回 dns_credential_missing(不 500,走人工兜底)');
384
- }
385
- }
386
- ctx.done(data);
387
- return data;
388
- },
389
- };
390
-
391
- /* ------------------------------ 动作 4:delete ------------------------------ */
392
-
393
- export const dnsCredentialDeleteCommand = {
394
- name: 'domain dns credential delete',
395
- summary: '删掉域名上的 DNS 凭据(必须 --yes;删后解析降级为人工兜底)',
396
- usage: 'wkgeo domain dns credential delete <域名> --yes',
397
- args: [{ name: 'domain', required: true, desc: '要删凭据的域名' }],
398
- flags: { yes: { type: 'boolean', desc: '确认真删(没有它只提示、不删)' } },
399
- examples: ['wkgeo domain dns credential delete example.com --yes'],
400
- notes: [
401
- '只删**凭据**,不动客户 DNS 上已经加好的解析记录(那是客户的资产,清理用解析记录删除动作)。',
402
- '删后 `status` 回 missing,发布/开通链路走 `dns_credential_missing` 人工兜底(不会 500)。',
403
- ],
404
- async run(ctx) {
405
- const { out, flags, positional } = ctx;
406
- const domain = String(positional.domain || '').trim();
407
- if (!domain) throw new UsageError('用法:wkgeo domain dns credential delete <域名> --yes');
408
- if (!flags.yes) {
409
- throw new UsageError(`删除 DNS 凭据需要显式确认:加 --yes\n 待删:${domain}`);
410
- }
411
- const data = (await callOps(ctx, 'dnsCredentialDelete', { domain }, '删除 DNS 凭据')) || {};
412
- if (!out.json) {
413
- if (data.deleted) out.ok(`已删除 ${data.domain || domain} 的 DNS 凭据(${labelOf(data.dns_provider)})`);
414
- else out.ok('本来就没配(幂等成功)');
415
- out.info(` 降级为:${data.degraded_to || 'dns_credential_missing'}(人工兜底,不 500)`);
416
- if (data.note) out.info(` ${data.note}`);
417
- }
418
- ctx.done(data);
419
- return data;
420
- },
421
- };
422
-
423
- export const DNS_CREDENTIAL_COMMANDS = [
424
- dnsCredentialDetectCommand,
425
- dnsCredentialSetCommand,
426
- dnsCredentialStatusCommand,
427
- dnsCredentialDeleteCommand,
428
- ];