wkgeo-cli 0.2.0

package/lib/errors.mjs

@@ -0,0 +1,268 @@
+/**
+ * 错误模型：把「服务端返回」翻译成「人能照做的下一步」。
+ *
+ * 本项目的**硬约定：HTTP 恒 200，错误在 body 的 `code` 里**（网关适配层统一信封）。
+ * 所以判断成败**不能看 HTTP 状态码**，必须看 `body.code`。这一点踩过坑：
+ * 早期 CLR 只看 `res.ok`，结果 403/429 全被当成"成功"，然后拿着空 data 崩在下一步。
+ *
+ * 但有三个地方**不遵守**这个约定，必须单独处理（否则会把 OAuth 标准错误当业务码）：
+ *   1. `GET /api/oauth/userinfo` → HTTP 401 + `{error:'invalid_token', error_description}`
+ *   2. `POST /api/oauth/token`   → HTTP 400 + `{error:'invalid_grant', error_description}`
+ *   3. `POST /api/oauth/introspect` → HTTP 200 + `{active:false}`（**不是错误**，是"无效"）
+ *
+ * 关于"过期"这个信号，线上新旧两种版本都存在，**两种都要认**：
+ *   * 新：`40101` 令牌已过期 ｜ `40102` 令牌已被吊销（本次另一个改动加的）
+ *   * 旧：只有 `401` + 文案"登录已过期，请重新登录"（过期/被吊销/没登录**完全一样**）
+ *   → 旧版只能给"运行 wkgeo login 重新授权"这种兼容提示，不能编造"是被吊销了"。
+ */
+
+export const EXIT = {
+  OK: 0,
+  /** 一般性失败（业务错误、服务端错误、网络错误、参数不合法之外的异常） */
+  ERROR: 1,
+  /** 用法错误（命令/参数不对）—— 与"跑失败"区分开，脚本里好判断 */
+  USAGE: 2,
+  /** 需要（重新）授权：未登录 / 令牌过期 / 已被吊销 */
+  AUTH: 3,
+  /** 被限流：**明确不要**引导重新授权 */
+  RATE_LIMIT: 4,
+};
+
+/** 需要重新授权时统一的下一步提示。命令名固定用官方 bin 名 `wkgeo`。 */
+export function loginHint(cmd = 'wkgeo') {
+  return `运行 \`${cmd} login\` 重新授权（浏览器里通常还有登录态，点一下同意即可）`;
+}
+
+export class CliError extends Error {
+  constructor(message, opts = {}) {
+    super(message);
+    this.name = 'CliError';
+    this.kind = opts.kind || 'error';
+    /** 服务端原始 code（数字或字符串），**必须保留**，不能吞掉 */
+    this.code = opts.code === undefined ? null : opts.code;
+    this.hint = opts.hint || null;
+    this.retryAfter = opts.retryAfter === undefined ? null : opts.retryAfter;
+    this.exitCode = opts.exitCode === undefined ? EXIT.ERROR : opts.exitCode;
+    /** 原始响应（已脱敏），--verbose 时打印，便于排查"服务端到底说了什么" */
+    this.raw = opts.raw === undefined ? null : opts.raw;
+    this.cause = opts.cause;
+  }
+}
+
+export class UsageError extends CliError {
+  constructor(message, opts = {}) {
+    super(message, { ...opts, kind: 'usage', exitCode: EXIT.USAGE });
+    this.name = 'UsageError';
+  }
+}
+
+/** 网络层失败：**保留原始 message**，绝不吞成"失败了" */
+export function networkError(detail, extra = {}) {
+  return new CliError(`网络请求失败：${detail}`, {
+    kind: 'network',
+    hint: '检查网络/代理或稍后重试；若持续失败请确认服务是否正常（服务地址可用 --base 临时切换）',
+    raw: extra.raw === undefined ? null : extra.raw,
+    cause: extra.cause,
+  });
+}
+
+/** 把服务端的 `code` 统一成数字（服务端有时回字符串） */
+function toCodeNumber(code) {
+  if (code === undefined || code === null || code === '') return null;
+  const n = Number(code);
+  return Number.isFinite(n) ? n : null;
+}
+
+/**
+ * "令牌无效"这一类错误（code=401 或 OAuth 标准的 invalid_token）到底该引导用户做什么。
+ *
+ * 背景（线上实测，2026-09-30）：
+ *   * `/api/data` 与 `/api/oauth/userinfo` 现在都回 **HTTP 401 + `error:invalid_token`**，
+ *     但 `error_description` 已经能区分：`访问令牌已被吊销，请重新授权` / 过期文案；
+ *   * 旧版则是一律 `登录已过期，请重新登录`；
+ *   * 新版的独立错误码 `40101/40102` **还没上线**（本次另一个改动在做）。
+ * 所以这里**只按文案细化提示**，绝不编造 code —— 报告里要能说清"是文案判的还是码判的"。
+ */
+function unauthenticatedClass(message, { httpStatus = 401, cmdName = 'wkgeo' } = {}) {
+  const text = String(message || '');
+  const base = {
+    code: text && httpStatus ? httpStatus : httpStatus,
+    exitCode: EXIT.AUTH,
+  };
+  if (/吊销|撤销|revoked/i.test(text)) {
+    return {
+      kind: 'revoked',
+      ok: false,
+      message: text,
+      hint: `授权已被吊销，请重新登录授权：\`${cmdName} login\`（服务端没有给出可区分的错误码，是按文案判定的）`,
+      retryAfter: null,
+      ...base,
+    };
+  }
+  if (/过期|expired/i.test(text)) {
+    return {
+      kind: 'expired',
+      ok: false,
+      message: text,
+      hint: `${loginHint(cmdName)}（服务端没有给出可区分的错误码，是按文案判定的）`,
+      retryAfter: null,
+      ...base,
+    };
+  }
+  return {
+    kind: 'unauthenticated',
+    ok: false,
+    message: text || '登录已过期，请重新登录',
+    hint: `${loginHint(cmdName)}（服务端只回了 401/invalid_token，"过期"与"被吊销"分不出来）`,
+    retryAfter: null,
+    ...base,
+  };
+}
+
+/**
+ * 判定一次响应。
+ * @returns {{kind:string, ok:boolean, code:any, message:string, hint:string|null, retryAfter:number|null, exitCode:number}}
+ * kind 取值：ok / network / expired / revoked / unauthenticated / rate_limited /
+ *            forbidden / step_up / bad_request / not_found / server / denied / unknown
+ */
+export function classifyResponse({ httpStatus = 200, body = null, action = '', retryAfterHeader = null, cmdName = 'wkgeo' } = {}) {
+  const ok = (extra = {}) => ({ kind: 'ok', ok: true, code: 0, message: '', hint: null, retryAfter: null, exitCode: EXIT.OK, ...extra });
+  const bad = (kind, message, extra = {}) => ({
+    kind,
+    ok: false,
+    code: extra.code === undefined ? null : extra.code,
+    message: message || '请求失败（服务端未给出原因）',
+    hint: extra.hint === undefined ? null : extra.hint,
+    retryAfter: extra.retryAfter === undefined ? null : extra.retryAfter,
+    exitCode: extra.exitCode === undefined ? EXIT.ERROR : extra.exitCode,
+  });
+
+  const retryAfterOf = (src) => {
+    const cand = [
+      src && src.retry_after,
+      src && src.data && src.data.retry_after,
+      retryAfterHeader,
+    ];
+    for (const c of cand) {
+      const n = Number(c);
+      if (Number.isFinite(n) && n >= 0) return n;
+    }
+    return null;
+  };
+
+  // ---- 1. 网络层（连不上/超时）：没有 body，status 0 ----
+  if (httpStatus === 0) {
+    return bad('network', typeof body === 'string' ? body : (body && body.message) || '连接失败', {
+      hint: '检查网络或稍后重试',
+    });
+  }
+
+  // ---- 2. OAuth 标准错误形状（userinfo / token / revoke / introspect）----
+  if (body && typeof body === 'object' && typeof body.error === 'string' && body.code === undefined) {
+    const err = body.error;
+    const desc = String(body.error_description || body.message || err);
+    if (err === 'invalid_token') {
+      // userinfo 的 401：OAuth 标准只有一个 invalid_token，但线上文案已经能区分吊销/过期
+      return unauthenticatedClass(desc, { httpStatus: httpStatus || 401, cmdName });
+    }
+    if (err === 'slow_down') {
+      const ra = retryAfterOf(body);
+      return bad('rate_limited', desc, {
+        code: 429,
+        retryAfter: ra,
+        hint: ra === null ? '调用过于频繁，请稍后重试（**不需要**重新授权）' : `调用过于频繁，请 ${ra} 秒后重试（**不需要**重新授权）`,
+        exitCode: EXIT.RATE_LIMIT,
+      });
+    }
+    if (err === 'invalid_grant') {
+      return bad('bad_request', desc, {
+        code: 400,
+        hint: '授权码可能已过期（5 分钟）或被使用过；重新运行 `' + cmdName + ' login` 即可',
+        exitCode: EXIT.ERROR,
+      });
+    }
+    if (err === 'access_denied') {
+      return bad('denied', desc, { code: 403, hint: '用户拒绝了授权' });
+    }
+    if (err === 'server_error') return bad('server', desc, { code: httpStatus || 500 });
+    return bad('unknown', desc, { code: httpStatus, exitCode: httpStatus >= 500 ? EXIT.ERROR : EXIT.ERROR });
+  }
+
+  // ---- 3. 项目统一信封 {code, message, data} ----
+  const codeNum = toCodeNumber(body && body.code);
+  const message = String((body && (body.message || body.msg)) || '');
+  const ra = retryAfterOf(body);
+
+  if (codeNum === 0) return ok();
+
+  if (codeNum === 40101) {
+    return bad('expired', message || '访问令牌已过期', {
+      code: 40101,
+      hint: loginHint(cmdName),
+      exitCode: EXIT.AUTH,
+    });
+  }
+  if (codeNum === 40102) {
+    return bad('revoked', message || '访问令牌已被吊销', {
+      code: 40102,
+      hint: `授权已被吊销，请重新登录授权：\`${cmdName} login\``,
+      exitCode: EXIT.AUTH,
+    });
+  }
+  if (codeNum === 401) {
+    return unauthenticatedClass(message, { httpStatus: 401, cmdName });
+  }
+  if (codeNum === 429 || httpStatus === 429) {
+    return bad('rate_limited', message || '调用过于频繁', {
+      code: 429,
+      retryAfter: ra,
+      // ⚠️ 限流**绝不能**引导用户去重新授权：重授权解决不了限流，还会白跑一遍浏览器。
+      hint: ra === null
+        ? '调用过于频繁，请稍后重试（**不需要**重新授权）'
+        : `调用过于频繁，请 ${ra} 秒后重试（**不需要**重新授权）`,
+      exitCode: EXIT.RATE_LIMIT,
+    });
+  }
+  if (codeNum === 403) {
+    const hint = /未授予|scope|令牌范围/i.test(message)
+      ? `令牌的能力不足（scope 收敛）。若确实需要该能力：\`${cmdName} login --scope "site:read site:write billing:self"\` 重新授权`
+      : '权限不足：敏感动作（动钱/改权限）需要二次验证，OAuth 令牌做不到，请在网页后台操作';
+    return bad('forbidden', message || '无权限', { code: 403, hint });
+  }
+  if (codeNum === 428) {
+    return bad('step_up', message || '需要二次验证', {
+      code: 428,
+      hint: '该动作要求 5 分钟内重新输入密码（step-up）。CLI 令牌没有密码入口 → 请在网页后台操作',
+    });
+  }
+  if (codeNum === 404) return bad('not_found', message || '资源不存在', { code: 404 });
+  if (codeNum === 400) return bad('bad_request', message || '请求不合法', { code: 400 });
+  if (codeNum !== null && codeNum >= 500) return bad('server', message || `服务端错误（${codeNum}）`, { code: codeNum });
+  if (codeNum !== null) return bad('unknown', message || `未知错误（code=${codeNum}）`, { code: codeNum });
+
+  // ---- 4. 既没有 code 也没有 error：按 HTTP 状态兜底（例如网关 5xx 直出）----
+  if (httpStatus >= 500) return bad('server', message || `服务端错误（HTTP ${httpStatus}）`, { code: httpStatus });
+  if (httpStatus === 401) {
+    return unauthenticatedClass(message, { httpStatus: 401, cmdName });
+  }
+  if (httpStatus >= 400) return bad('unknown', message || `请求失败（HTTP ${httpStatus}）`, { code: httpStatus });
+  if (httpStatus >= 200 && httpStatus < 300) {
+    // HTTP 200 但没有 code 字段：可能是纯 REST 形状（比如 PG REST 直出数组）。
+    // 这种不算错，交给调用方处理 body 本身。
+    return ok({ code: null });
+  }
+  return bad('unknown', message || `无法识别的响应（HTTP ${httpStatus}）`, { code: httpStatus });
+}
+
+/** 把 classify 结果变成可抛出的 CliError */
+export function toCliError(classified, { action = '', raw = null } = {}) {
+  const where = action ? `（${action}）` : '';
+  return new CliError(`${classified.message}${where ? ' ' + where : ''}`, {
+    kind: classified.kind,
+    code: classified.code,
+    hint: classified.hint,
+    retryAfter: classified.retryAfter,
+    exitCode: classified.exitCode,
+    raw,
+  });
+}

package/lib/format.mjs

@@ -0,0 +1,204 @@
+/**
+ * 输出格式化：金额、掩码、表格、脱敏、颜色。
+ *
+ * 安全铁律（本文件就是守卫者）：
+ *   * 令牌/授权码/verifier **永远不进终端**。需要指代时只给"前 6 位 + 长度"的掩码。
+ *   * 任何"把服务端原始响应打出来"的地方都必须先过 `redact()` ——
+ *     因为 `/api/oauth/token` 的响应体里就有明文 access_token。
+ */
+
+/* ------------------------------------------------------------------ */
+/* 掩码 / 脱敏                                                          */
+/* ------------------------------------------------------------------ */
+
+/** 掩码：保留前 6 位 + 总长度，够定位是哪一把，但抄不走 */
+export function maskToken(value) {
+  const s = String(value ?? '');
+  if (!s) return '(空)';
+  if (s.length <= 8) return `${s.slice(0, 2)}…(${s.length} 位)`;
+  return `${s.slice(0, 6)}…(${s.length} 位)`;
+}
+
+/** 需要脱敏的键名（大小写不敏感、子串匹配） */
+const SECRET_KEY_PATTERNS = [
+  'access_token',
+  'refresh_token',
+  'client_secret',
+  'code_verifier',
+  'authorization',
+  'password',
+  'id_token',
+  'token_hash',
+];
+
+/**
+ * ⚠️ 踩过的坑：一开始把键名 `code` 一律当秘密，结果把**错误码** `code: 40101`
+ *    也脱敏成了 «已脱敏»，AI 端拿不到 code 就没法分支处理。
+ *    第二版用"长度 ≥ 16 且不是纯数字"，又把 `insufficient_balance`（20 字符的
+ *    语义化错误码）误伤了。现在阈值提到 32：授权码是 43 字符的随机串，
+ *    而错误码/产品代码通常短得多。
+ */
+function looksLikeAuthorizationCode(value) {
+  return typeof value === 'string' && value.length >= 32;
+}
+
+function isSecretKey(key, value) {
+  const k = String(key).toLowerCase();
+  // 注意：这些**不是**秘密，别误伤：
+  //   token_count / token_endpoint / token_type / *_ttl_seconds
+  //   authorization_url —— 它就是要交给用户去浏览器打开的地址，
+  //   一开始被 `authorization` 子串误伤，结果 AI 端拿到的"授权网址"变成了 «已脱敏»（真实踩过）
+  if (
+    k === 'token_type' ||
+    k === 'token_count' ||
+    k === 'authorization_url' ||
+    k.endsWith('_endpoint') ||
+    k.endsWith('_ttl_seconds')
+  ) {
+    return false;
+  }
+  if (k === 'code') return looksLikeAuthorizationCode(value);
+  return SECRET_KEY_PATTERNS.some((p) => k.includes(p));
+}
+
+/** 递归脱敏一个对象（用于 --verbose / --debug 打印原始响应） */
+export function redact(value, depth = 0) {
+  if (depth > 6) return '…';
+  if (value === null || value === undefined) return value;
+  if (Array.isArray(value)) return value.map((v) => redact(v, depth + 1));
+  if (typeof value === 'object') {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = isSecretKey(k, v) ? `«已脱敏:${maskToken(v)}»` : redact(v, depth + 1);
+    }
+    return out;
+  }
+  return value;
+}
+
+/** 安全的 JSON 字符串（脱敏 + 容错循环引用） */
+export function safeJson(value, indent = 2) {
+  try {
+    return JSON.stringify(redact(value), null, indent);
+  } catch {
+    return String(value);
+  }
+}
+
+/* ------------------------------------------------------------------ */
+/* 金额 / 时间                                                          */
+/* ------------------------------------------------------------------ */
+
+/** 分 → `¥1.00`（服务端所有金额都是"分"，且不一定是整数，所以先 Number 再判） */
+export function formatMoney(cents) {
+  const n = Number(cents);
+  if (!Number.isFinite(n)) return `¥${cents ?? '?'}`;
+  return `¥${(n / 100).toFixed(2)}`;
+}
+
+/** ISO 时间 → `2026-09-30 12:00:00`（本地时区；服务端回的是 UTC ISO） */
+export function formatTime(value) {
+  if (!value) return '-';
+  const d = new Date(value);
+  if (Number.isNaN(d.getTime())) return String(value);
+  const p = (n) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
+}
+
+/** 剩余时长的人话：`还剩 29 天 23 小时` */
+export function formatRemaining(ms) {
+  if (!Number.isFinite(ms)) return '未知';
+  if (ms <= 0) return '已过期';
+  const s = Math.floor(ms / 1000);
+  const d = Math.floor(s / 86400);
+  const h = Math.floor((s % 86400) / 3600);
+  const m = Math.floor((s % 3600) / 60);
+  if (d > 0) return `还剩 ${d} 天 ${h} 小时`;
+  if (h > 0) return `还剩 ${h} 小时 ${m} 分`;
+  return `还剩 ${m} 分 ${s % 60} 秒`;
+}
+
+/* ------------------------------------------------------------------ */
+/* 表格（按显示宽度对齐，中文算 2 列）                                     */
+/* ------------------------------------------------------------------ */
+
+/** CJK / 全角字符按 2 列宽计算，否则中文表格会歪（踩过：全用 .length 对齐，列参差不齐） */
+export function displayWidth(str) {
+  let w = 0;
+  for (const ch of String(str ?? '')) {
+    const cp = ch.codePointAt(0);
+    const wide =
+      (cp >= 0x1100 && cp <= 0x115f) ||
+      (cp >= 0x2e80 && cp <= 0xa4cf) ||
+      (cp >= 0xac00 && cp <= 0xd7a3) ||
+      (cp >= 0xf900 && cp <= 0xfaff) ||
+      (cp >= 0xfe30 && cp <= 0xfe6f) ||
+      (cp >= 0xff00 && cp <= 0xff60) ||
+      (cp >= 0xffe0 && cp <= 0xffe6);
+    w += wide ? 2 : 1;
+  }
+  return w;
+}
+
+function padEndWide(str, width) {
+  const s = String(str ?? '');
+  const pad = width - displayWidth(s);
+  return pad > 0 ? s + ' '.repeat(pad) : s;
+}
+
+function truncateWide(str, width) {
+  let s = String(str ?? '');
+  if (displayWidth(s) <= width) return s;
+  let out = '';
+  let w = 0;
+  for (const ch of s) {
+    const cw = displayWidth(ch);
+    if (w + cw > width - 1) break;
+    out += ch;
+    w += cw;
+  }
+  return out + '…';
+}
+
+/**
+ * 渲染简单表格。
+ * @param {Array<{title:string, key:string, width?:number, format?:Function}>} columns
+ * @param {Array<object>} rows
+ */
+export function renderTable(columns, rows) {
+  if (!rows || rows.length === 0) return '（没有数据）';
+  const cells = rows.map((r) =>
+    columns.map((c) => {
+      const raw = c.format ? c.format(r[c.key], r) : r[c.key];
+      return raw === undefined || raw === null || raw === '' ? '-' : String(raw);
+    }),
+  );
+  const widths = columns.map((c, i) => {
+    const natural = Math.max(displayWidth(c.title), ...cells.map((row) => displayWidth(row[i])));
+    const cap = c.width || 42;
+    return Math.min(natural, cap);
+  });
+  const head = columns.map((c, i) => padEndWide(c.title, widths[i])).join('  ');
+  const sep = widths.map((w) => '─'.repeat(w)).join('  ');
+  const body = cells
+    .map((row) => row.map((cell, i) => padEndWide(truncateWide(cell, widths[i]), widths[i])).join('  '))
+    .join('\n');
+  return `${head}\n${sep}\n${body}`;
+}
+
+/* ------------------------------------------------------------------ */
+/* 颜色（只在 TTY 且没被 --no-color 关掉时用）                             */
+/* ------------------------------------------------------------------ */
+
+export function createPalette({ enabled = true } = {}) {
+  const wrap = (code) => (s) => (enabled ? `\u001b[${code}m${s}\u001b[0m` : String(s));
+  return {
+    enabled,
+    green: wrap('32'),
+    red: wrap('31'),
+    yellow: wrap('33'),
+    cyan: wrap('36'),
+    dim: wrap('2'),
+    bold: wrap('1'),
+  };
+}

package/lib/http.mjs

@@ -0,0 +1,71 @@
+/**
+ * HTTP 薄封装：超时、JSON、错误不吞。
+ *
+ * 为什么不用 axios/got/node-fetch：
+ *   1. 老板明确要"尽量零第三方依赖"（npx 一行就能跑、审计面小、不怕供应链）。
+ *   2. Node 18+ 自带 fetch，够用。
+ *
+ * 为什么返回 `{status:0, networkError}` 而不是直接 throw：
+ *   调用方需要**保留原始 message**（DNS 失败？TLS 失败？超时？），
+ *   而这些信息只有 catch 里才有。统一在这里收口，上层就不会写出"失败了"这种吞错误的代码。
+ */
+
+export const DEFAULT_TIMEOUT_MS = 30000;
+
+/**
+ * @returns {Promise<{status:number, headers:any, text:string, body:any, parseError:string|null, networkError?:string, cause?:any}>}
+ */
+export async function request(url, options = {}) {
+  const {
+    method = 'GET',
+    headers = {},
+    body,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    fetchImpl = globalThis.fetch,
+    redirect = 'follow',
+  } = options;
+
+  if (typeof fetchImpl !== 'function') {
+    return { status: 0, headers: null, text: '', body: null, parseError: null, networkError: '当前 Node 没有可用的 fetch（需要 Node 18+）' };
+  }
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetchImpl(url, { method, headers, body, signal: controller.signal, redirect });
+    const text = await res.text();
+    let parsed = null;
+    let parseError = null;
+    if (text) {
+      try {
+        parsed = JSON.parse(text);
+      } catch (e) {
+        parseError = e.message;
+      }
+    }
+    return { status: res.status, headers: res.headers, text, body: parsed, parseError };
+  } catch (e) {
+    const aborted = e && (e.name === 'AbortError' || /aborted/i.test(String(e.message)));
+    return {
+      status: 0,
+      headers: null,
+      text: '',
+      body: null,
+      parseError: null,
+      networkError: aborted ? `请求超时（${timeoutMs}ms 内没有响应）` : (e && e.message) || String(e),
+      cause: e,
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/** form-urlencoded 编码（OAuth 的 token/revoke/introspect 三个端点都用它） */
+export function encodeForm(obj) {
+  const usp = new URLSearchParams();
+  for (const [k, v] of Object.entries(obj || {})) {
+    if (v === undefined || v === null) continue;
+    usp.append(k, String(v));
+  }
+  return usp.toString();
+}

package/lib/index.mjs

@@ -0,0 +1,39 @@
+/**
+ * 库入口（给"想在 Node 里直接调"的用法，比如我们自己的 AI 端把 CLI 当函数用）。
+ *
+ * ⚠️ 这里导出的东西**都不打印令牌**；`login()` 返回的对象里含 access_token，
+ *    调用方自己要负责不要把它打到日志里（CLI 内部就是这么做的）。
+ */
+
+export { run } from './cli.mjs';
+export { createRuntime, createOutput, okEnvelope, errorEnvelope } from './runtime.mjs';
+export { createApi } from './api.mjs';
+export {
+  runLogin,
+  openInBrowser,
+  defaultOpenBrowser,
+  defaultOpenBrowserAsync,
+  openInBrowserWithFallback,
+  /** 「把网址交给用户浏览器」的唯一入口（login / 钱包充值共用） */
+  openUrlForUser,
+} from './login.mjs';
+export { COMMANDS, renderHelp } from './commands/index.mjs';
+export {
+  resolveConfig,
+  stripTrailingSlash,
+  withTrailingSlash,
+  parseDurationMs,
+  DEFAULT_BASE,
+  DEFAULT_CLIENT_ID,
+  DEFAULT_SCOPE,
+} from './config.mjs';
+export {
+  readCredentials,
+  writeCredentials,
+  deleteCredentials,
+  credentialsFromToken,
+  checkFileMode,
+} from './credentials.mjs';
+export { classifyResponse, CliError, UsageError, EXIT } from './errors.mjs';
+export { createVerifier, challengeOf, createState } from './pkce.mjs';
+export { maskToken, redact, formatMoney, renderTable } from './format.mjs';