wkgeo-cli 0.2.0

package/lib/commands/orders.mjs

@@ -0,0 +1,444 @@
+/**
+ * 订单命令：`products list` / `orders create` / `orders pay` / `orders list`
+ *
+ * ## 「钱包余额支付」在本项目里到底发生在哪一步（重要，别被命令名骗了）
+ *
+ * 服务端 `placeOrder()` 的行为是：**下单时就先用余额抵扣**，
+ * 余额足够 → `moveWallet(-金额)` + `fulfillOrder()` → 直接返回 `paid: true`。
+ * 也就是说"用钱包支付"是**下单动作的一部分**，不是独立的一步。
+ *
+ * 所以本 CLI 的口径：
+ *   * `orders create`  = 下单 + （余额够就）完成支付，返回值里 `paid` 说明结果；
+ *   * `orders pay <id>` = 对**还没支付**的订单做"查单/收敛状态"（服务端 checkOrder）：
+ *       微信侧已支付而本地还是 pending → 就地履约；否则告诉你还在等支付。
+ *   * CLI **永远不会**自己去扫微信码 / 发起任何真实扣款。
+ *
+ * ⚠️ 没有做"把余额补到一个已存在的 pending 订单上"的命令 —— 服务端**没有这个 action**
+ *    （`placeOrder` 里余额抵扣只在建单那一刻发生）。要做需要服务端新增接口，
+ *    这属于"要主线程决定"的事，已在报告里列出。
+ */
+
+import { UsageError, CliError, EXIT } from '../errors.mjs';
+import { formatMoney, formatTime } from '../format.mjs';
+import { renderQrOptional } from '../qr.mjs';
+
+/* ------------------------------------------------------------------ */
+/* products list                                                       */
+/* ------------------------------------------------------------------ */
+
+export const productsListCommand = {
+  name: 'products list',
+  summary: '可购买的产品/加量包（用来找 --product 该填什么）',
+  usage: 'wkgeo products list',
+  async run(ctx) {
+    const { out } = ctx;
+    const res = await ctx.callData('listProducts', {});
+    const rows = (res && Array.isArray(res.rows) ? res.rows : []).map((p) => {
+      const params = p.params || {};
+      return {
+        code: p.code,
+        name: p.name,
+        kind: p.kind,
+        unit: p.unit,
+        price_cents: p.price_cents,
+        price_text: formatMoney(p.price_cents),
+        quota_key: params.quota_key || null,
+        quota_multiplier: params.quota_multiplier ?? null,
+        min_qty: p.min_qty ?? null,
+        max_qty: p.max_qty ?? null,
+      };
+    });
+    const data = { rows };
+    if (!out.json) {
+      out.head(`可购买的产品（${rows.length} 项）`);
+      out.table(
+        [
+          { title: '产品代码', key: 'code', width: 24 },
+          { title: '名称', key: 'name', width: 20 },
+          { title: '类型', key: 'kind', width: 14 },
+          { title: '单价', key: 'price_text', width: 10 },
+          { title: '单位', key: 'unit', width: 8 },
+          { title: '配额键', key: 'quota_key', width: 16 },
+          { title: '倍率', key: 'quota_multiplier', width: 6 },
+        ],
+        rows,
+      );
+      out.info('  下单示例：wkgeo orders create --product <产品代码> --units 1');
+    }
+    ctx.done(data);
+    return data;
+  },
+};
+
+/* ------------------------------------------------------------------ */
+/* orders create                                                       */
+/* ------------------------------------------------------------------ */
+
+export const ordersCreateCommand = {
+  name: 'orders create',
+  summary: '下单（余额足够时**当场用钱包余额付清**；不会发起真实微信扣款）',
+  usage:
+    'wkgeo orders create --product <产品代码> --units <份数> [--allow-wechat]\n' +
+    'wkgeo orders create --quota <配额键> --amount <基础单位数> [--allow-wechat]',
+  flags: {
+    product: { type: 'string', desc: '产品代码或配额键（见 `wkgeo products list`）' },
+    units: { type: 'string', desc: '购买份数（默认 1，按产品单位计价）' },
+    quota: { type: 'string', desc: '直接指定配额键（如 storage_mb）' },
+    amount: { type: 'string', desc: '直接指定基础单位数量（配合 --quota）' },
+    'allow-wechat': {
+      type: 'boolean',
+      desc: '余额不足时仍创建订单（会返回微信 code_url，**需要用户自己扫码**；CLI 不会扣款）',
+    },
+  },
+  async run(ctx) {
+    const { out, flags } = ctx;
+
+    if (!flags.product && !flags.quota) {
+      throw new UsageError('需要 --product <产品代码> 或 --quota <配额键>（用 `wkgeo products list` 查可用产品）');
+    }
+    if (flags.product && flags.quota) {
+      throw new UsageError('--product 与 --quota 不能同时使用');
+    }
+
+    let quotaKey;
+    let quotaAmount;
+    let units = null;
+    let estimateCents = null;
+    let productInfo = null;
+
+    if (flags.product) {
+      units = flags.units === undefined ? 1 : Number(flags.units);
+      if (!Number.isInteger(units) || units <= 0) throw new UsageError(`--units 必须是正整数，收到：${flags.units}`);
+
+      const catalog = await ctx.callData('listProducts', {});
+      const list = (catalog && Array.isArray(catalog.rows) ? catalog.rows : []).map((p) => ({
+        ...p,
+        params: p.params || {},
+      }));
+      const hit =
+        list.find((p) => p.code === flags.product) ||
+        list.find((p) => p.params.quota_key === flags.product && p.kind === 'resource');
+
+      if (!hit) {
+        throw new CliError(`找不到产品（或配额键）「${flags.product}」`, {
+          kind: 'not_found',
+          code: 404,
+          hint: `用 \`wkgeo products list\` 看可用产品代码；也可用 --quota <配额键> --amount <数量> 直接按配额下单`,
+        });
+      }
+      if (hit.kind !== 'resource' || !hit.params.quota_key) {
+        throw new CliError(`产品「${hit.code}」是 ${hit.kind} 类型，当前 CLI 只支持"加量包/资源型"下单`, {
+          kind: 'unsupported',
+          code: 400,
+          hint: '订阅套餐请在网页后台自助购买（金额较大且会改订阅权益）',
+        });
+      }
+      const mult = Number(hit.params.quota_multiplier) || 1;
+      quotaKey = hit.params.quota_key;
+      quotaAmount = units * mult;
+      estimateCents = units * (Number(hit.price_cents) || 0);
+      productInfo = {
+        code: hit.code,
+        name: hit.name,
+        unit: hit.unit || '份',
+        unit_price_cents: Number(hit.price_cents) || 0,
+        quota_multiplier: mult,
+      };
+    } else {
+      quotaKey = flags.quota;
+      quotaAmount = Number(flags.amount);
+      if (!Number.isInteger(quotaAmount) || quotaAmount <= 0) {
+        throw new UsageError(`--amount 必须是正整数（基础单位数量），收到：${flags.amount}`);
+      }
+      units = null;
+    }
+
+    /* ---- 钱包预检：余额不足时**默认拒绝**，而不是悄悄建一张要扫码的单 ---- */
+    let balanceBefore = null;
+    try {
+      const w = await ctx.callData('getMyWallet', { limit: 1 });
+      balanceBefore = Number(w && w.balance_cents) || 0;
+    } catch (e) {
+      out.warn(`读取钱包余额失败（继续下单）：${e.message}`);
+    }
+    if (
+      balanceBefore !== null &&
+      estimateCents !== null &&
+      balanceBefore < estimateCents &&
+      flags.allowWechat !== true
+    ) {
+      throw new CliError(
+        `钱包余额不足：本单需要 ${formatMoney(estimateCents)}，当前余额 ${formatMoney(balanceBefore)}`,
+        {
+          kind: 'insufficient_balance',
+          code: 'insufficient_balance',
+          hint:
+            'CLI **不会**发起真实微信支付。请先在网页充够余额再下单；' +
+            '如果确实要用微信扫码，加 --allow-wechat 创建"待支付"订单（CLI 只打印支付链接，不扣款，也不替你确认支付）',
+          exitCode: EXIT.ERROR,
+        },
+      );
+    }
+
+    const res = await ctx.callData('createQuotaOrder', { quota_key: quotaKey, quota_amount: quotaAmount });
+    const paid = !!(res && res.paid);
+    const data = {
+      order_id: (res && res.order_id) || null,
+      out_trade_no: (res && res.out_trade_no) || null,
+      paid,
+      amount_cents: Number(res && res.amount_cents) || null,
+      amount_text: res && res.amount_cents !== undefined ? formatMoney(res.amount_cents) : null,
+      wallet_paid_cents: Number(res && res.wallet_paid_cents) || 0,
+      pay_amount_cents: res && res.pay_amount_cents !== undefined ? Number(res.pay_amount_cents) : null,
+      code_url: (res && res.code_url) || null,
+      expires_at_minutes: (res && res.expires_at_minutes) || null,
+      message: (res && res.message) || null,
+      product: productInfo,
+      quota: { quota_key: quotaKey, quota_amount: quotaAmount, units },
+      balance_before_cents: balanceBefore,
+      balance_after_cents:
+        balanceBefore !== null && paid ? balanceBefore - (Number(res && res.wallet_paid_cents) || 0) : balanceBefore,
+    };
+
+    if (!out.json) {
+      out.head('下单结果');
+      out.line(`  订单号：${data.order_id}`);
+      out.line(`  商户单号：${data.out_trade_no || '-'}`);
+      out.line(`  金额：${data.amount_text}`);
+      out.line(`  钱包抵扣：${formatMoney(data.wallet_paid_cents)}`);
+      if (data.balance_before_cents !== null) {
+        out.line(`  余额：${formatMoney(data.balance_before_cents)}${paid ? ` → ${formatMoney(data.balance_after_cents)}` : ''}`);
+      }
+      out.line('');
+      if (paid) {
+        out.ok(`订单已用**钱包余额**支付完成${data.message ? `（${data.message}）` : ''}`);
+      } else {
+        out.warn('订单已创建，但**尚未支付**（余额不足以覆盖全款）');
+        out.line(`  待支付金额：${formatMoney(data.pay_amount_cents)}`);
+        if (data.code_url) {
+          out.line('');
+          out.line('  微信支付链接（需要用手机扫码/打开）：');
+          out.line(`  ${data.code_url}`);
+          const qrShown = await renderQrOptional(data.code_url, out);
+          if (!qrShown) {
+            out.info('  （未安装可选的 qrcode-terminal，只打印链接；装了会自动画二维码）');
+          }
+          out.line('');
+          out.line(`  支付完成后运行：wkgeo orders pay ${data.order_id}`);
+        }
+        out.info('  CLI 不会发起真实微信扣款，也不会替你确认支付。');
+      }
+    }
+    ctx.done(data);
+    return data;
+  },
+};
+
+/* ------------------------------------------------------------------ */
+/* orders check / orders pay（同一实现，两个名字）                        */
+/* ------------------------------------------------------------------ */
+
+/**
+ * 轮询支付结果 + 展示最新余额。
+ *
+ * ⚠️ 这里是**只读**语义：`checkOrder` 只会问微信"这笔单付了没"，
+ *    服务端在"微信侧已支付但本地还是 pending"时就地履约 —— 这是补状态，不是发起支付。
+ *    CLI **绝不**模拟支付成功、也绝不自动扣款。
+ */
+async function checkOrderImpl(ctx, orderId) {
+  const { out } = ctx;
+  const res = await ctx.callData('checkOrder', { order_id: orderId });
+  const status = (res && res.status) || 'unknown';
+  const paid = !!(res && res.paid);
+
+  // 已支付时顺手把最新余额带出来（老板要的"成功后显示新余额"）
+  let balanceCents = null;
+  if (paid) {
+    try {
+      const w = await ctx.callData('getMyWallet', { limit: 1 });
+      balanceCents = Number((w && w.balance_cents) || 0);
+    } catch {
+      /* 余额拿不到不影响"已支付"这个结论 */
+    }
+  }
+
+  const data = {
+    order_id: orderId,
+    status,
+    paid,
+    fulfilled: !!(res && res.fulfilled),
+    trade_state: (res && res.trade_state) || null,
+    code_url: (res && res.code_url) || null,
+    balance_cents: balanceCents,
+    balance_text: balanceCents === null ? null : formatMoney(balanceCents),
+    order: (res && res.order) || null,
+  };
+
+  if (!out.json) {
+    if (paid) {
+      out.ok(`订单已支付：${orderId}（状态 ${status}${data.fulfilled ? '，已履约' : ''}）`);
+      if (balanceCents !== null) out.line(`  当前余额：${data.balance_text}`);
+    } else if (status === 'pending') {
+      out.warn(`订单仍未支付：${orderId}（微信侧状态 ${data.trade_state || 'NOTPAY'}）`);
+      if (data.code_url) {
+        out.line(`  支付链接：${data.code_url}`);
+        await renderQrOptional(data.code_url, out);
+      }
+      out.info('  请在手机上完成支付后再运行本命令确认；CLI 不会替你付款，也不会模拟支付成功。');
+    } else {
+      out.line(`订单状态：${status}`);
+    }
+  }
+  ctx.done(data);
+  return data;
+}
+
+export const ordersCheckCommand = {
+  name: 'orders check',
+  summary: '查询某笔订单的支付结果（微信侧已支付则就地履约），并显示最新余额',
+  usage: 'wkgeo orders check <订单ID>',
+  args: [{ name: 'orderId', required: true, desc: '订单 ID' }],
+  run: (ctx) => checkOrderImpl(ctx, ctx.positional.orderId),
+};
+
+/** `orders pay` 与 `orders check` 是**同一实现**：保留 pay 这个名字是因为
+ *  老板给的任务表里写的是 `orders pay <orderId>`（核心：完成"支付操作"）。
+ *  真实语义在下单那一步就支付完成了，这里只是查/收敛状态，详见本文件顶部说明。 */
+export const ordersPayCommand = {
+  name: 'orders pay',
+  summary: '（`orders check` 的别名）确认/收敛订单支付状态并显示最新余额',
+  usage: 'wkgeo orders pay <订单ID>',
+  args: [{ name: 'orderId', required: true, desc: '订单 ID' }],
+  run: (ctx) => checkOrderImpl(ctx, ctx.positional.orderId),
+};
+
+/* ------------------------------------------------------------------ */
+/* orders get                                                          */
+/* ------------------------------------------------------------------ */
+
+export const ordersGetCommand = {
+  name: 'orders get',
+  summary: '看某笔订单的详情（在自己的订单列表里查找，不触发任何微信查询）',
+  usage: 'wkgeo orders get <订单ID> [--max-scan 1000]',
+  args: [{ name: 'orderId', required: true, desc: '订单 ID' }],
+  flags: {
+    'max-scan': { type: 'string', desc: '最多翻查多少条历史订单（默认 1000）' },
+  },
+  async run(ctx) {
+    const { out, flags } = ctx;
+    const orderId = ctx.positional.orderId;
+    const maxScan = Math.min(Math.max(Number(flags.maxScan) || 1000, 100), 5000);
+
+    /**
+     * 为什么是"翻列表"而不是专用接口：
+     *   服务端**没有** `getMyOrder(id)` 这个 action（只有 `checkOrder`）。
+     *   而 `checkOrder` 对 pending 订单会去问微信 —— 一个"看详情"的命令不该有外部副作用，
+     *   所以这里只翻自己的订单列表（`listMyOrders`，每页 100）。
+     */
+    let found = null;
+    let scanned = 0;
+    for (let offset = 0; offset < maxScan; offset += 100) {
+      const res = await ctx.callData('listMyOrders', { limit: 100, offset });
+      const rows = (res && Array.isArray(res.rows) ? res.rows : []);
+      scanned += rows.length;
+      found = rows.find((r) => r.id === orderId || r.out_trade_no === orderId) || null;
+      if (found || rows.length < 100) break;
+    }
+
+    if (!found) {
+      throw new CliError(`在你最近的 ${scanned} 条订单里没找到「${orderId}」`, {
+        kind: 'not_found',
+        code: 404,
+        hint: `该订单可能更早（可加 --max-scan 扩大范围），或不是当前账号的订单；要看实时支付状态可用 \`wkgeo orders check ${orderId}\``,
+      });
+    }
+
+    const data = {
+      order: {
+        id: found.id,
+        out_trade_no: found.out_trade_no,
+        kind: found.kind,
+        status: found.status,
+        amount_cents: Number(found.amount_cents) || 0,
+        amount_text: formatMoney(found.amount_cents),
+        wallet_paid_cents: Number(found.wallet_paid_cents) || 0,
+        wallet_paid_text: formatMoney(found.wallet_paid_cents),
+        currency: found.currency || null,
+        transaction_id: found.transaction_id || null,
+        paid_at: found.paid_at || null,
+        expires_at: found.expires_at || null,
+        created_at: found.created_at || null,
+        payload: found.payload || {},
+      },
+      scanned,
+    };
+
+    if (!out.json) {
+      const o = data.order;
+      out.head('订单详情');
+      out.line(`  订单号：${o.id}`);
+      out.line(`  商户单号：${o.out_trade_no || '-'}`);
+      out.line(`  类型/状态：${o.kind} / ${o.status}`);
+      out.line(`  金额：${o.amount_text}（余额支付 ${o.wallet_paid_text}）`);
+      out.line(`  创建时间：${formatTime(o.created_at)}`);
+      out.line(`  支付时间：${formatTime(o.paid_at)}`);
+      out.line(`  微信交易号：${o.transaction_id || '-'}`);
+      out.line(`  商品明细：${JSON.stringify(o.payload)}`);
+    }
+    ctx.done(data);
+    return data;
+  },
+};
+
+/* ------------------------------------------------------------------ */
+/* orders list                                                         */
+/* ------------------------------------------------------------------ */
+
+export const ordersListCommand = {
+  name: 'orders list',
+  summary: '我的订单列表',
+  usage: 'wkgeo orders list [--limit 20] [--offset 0] [--status paid]',
+  flags: {
+    limit: { type: 'string', desc: '返回条数（1~100，默认 20）' },
+    offset: { type: 'string', desc: '偏移（默认 0）' },
+    status: { type: 'string', desc: '只看某个状态（pending/paid/refunded/failed/closed）' },
+  },
+  async run(ctx) {
+    const { out, flags } = ctx;
+    const payload = {};
+    if (flags.limit !== undefined) payload.limit = Number(flags.limit);
+    if (flags.offset !== undefined) payload.offset = Number(flags.offset);
+    const res = await ctx.callData('listMyOrders', payload);
+    let rows = (res && Array.isArray(res.rows) ? res.rows : []).map((r) => ({
+      id: r.id,
+      out_trade_no: r.out_trade_no,
+      kind: r.kind,
+      status: r.status,
+      amount_cents: Number(r.amount_cents) || 0,
+      amount_text: formatMoney(r.amount_cents),
+      wallet_paid_cents: Number(r.wallet_paid_cents) || 0,
+      wallet_paid_text: formatMoney(r.wallet_paid_cents),
+      paid_at: r.paid_at || null,
+      created_at: r.created_at,
+    }));
+    if (flags.status) rows = rows.filter((r) => r.status === flags.status);
+    const data = { rows, total: flags.status ? rows.length : (res && res.total) || rows.length };
+
+    if (!out.json) {
+      out.head(`我的订单（${data.total} 条${flags.status ? `，已按状态 ${flags.status} 过滤` : ''}）`);
+      out.table(
+        [
+          { title: '订单号', key: 'id', width: 38 },
+          { title: '类型', key: 'kind', width: 10 },
+          { title: '状态', key: 'status', width: 10 },
+          { title: '金额', key: 'amount_text', width: 10 },
+          { title: '余额支付', key: 'wallet_paid_text', width: 10 },
+          { title: '创建时间', key: 'created_at', format: (v) => formatTime(v), width: 20 },
+        ],
+        rows,
+      );
+    }
+    ctx.done(data);
+    return data;
+  },
+};

package/lib/commands/sites.mjs

@@ -0,0 +1,140 @@
+/**
+ * 站点命令：`sites list` / `sites create` / `sites delete`
+ *
+ * 归属口径（**服务端是权威，CLI 只做复核**）：
+ *   服务端 `handleCreateSite` 把 `owner_user_id` 和 `created_by` 都写成**令牌所属用户**，
+ *   客户端传什么都不作数。CLI 建完会回读一次并核对，避免"以为建在自己名下其实不是"。
+ *
+ * ⚠️ 已知服务端行为（与 OAuth 无关，是既有实现，踩过）：
+ *   `data_scope != 'self'` 的账号（如 owner/admin）**不传 `customer_id` 建站必 400
+ *   「无法确定所属客户」**。所以这里检测到这个错误时给出 `--customer` 的明确指引，
+ *   而不是让用户对着 400 发呆。
+ */
+
+import { CliError } from '../errors.mjs';
+import { formatTime } from '../format.mjs';
+
+function normalizeSite(res) {
+  const s = res || {};
+  return {
+    id: s.id || null,
+    name: s.name || null,
+    status: s.status || null,
+    domain: s.domain || null,
+    domains: Array.isArray(s.domains) ? s.domains : [],
+    owner_user_id: s.owner_user_id ? String(s.owner_user_id) : null,
+    created_by: s.created_by ? String(s.created_by) : null,
+    created_at: s.created_at || null,
+    expires_at: s.expires_at || null,
+  };
+}
+
+export const sitesListCommand = {
+  name: 'sites list',
+  summary: '我的站点列表',
+  usage: 'wkgeo sites list [--limit 50] [--offset 0]',
+  flags: {
+    limit: { type: 'string', desc: '返回条数（1~200，默认 50）' },
+    offset: { type: 'string', desc: '偏移（默认 0）' },
+  },
+  async run(ctx) {
+    const { out } = ctx;
+    const payload = {};
+    if (ctx.flags.limit !== undefined) payload.limit = Number(ctx.flags.limit);
+    if (ctx.flags.offset !== undefined) payload.offset = Number(ctx.flags.offset);
+    const res = await ctx.callData('listSites', payload);
+    const rows = (res && Array.isArray(res.rows) ? res.rows : []).map(normalizeSite);
+    const data = { rows, total: (res && res.total) || rows.length };
+
+    if (!out.json) {
+      out.head(`站点列表（共 ${data.total} 个${data.total > rows.length ? `，本页 ${rows.length} 条` : ''}）`);
+      out.table(
+        [
+          { title: '名称', key: 'name', width: 28 },
+          { title: '站点 ID', key: 'id', width: 38 },
+          { title: '状态', key: 'status', width: 10 },
+          { title: '主域名', key: 'domain', width: 24 },
+          { title: '创建时间', key: 'created_at', format: (v) => formatTime(v), width: 20 },
+        ],
+        rows,
+      );
+    }
+    ctx.done(data);
+    return data;
+  },
+};
+
+export const sitesCreateCommand = {
+  name: 'sites create',
+  summary: '建一个属于当前账号的站点（返回站点 id）',
+  usage: 'wkgeo sites create --name <名称> [--customer <客户ID>] [--template <模板ID>] [--domain <域名>]',
+  flags: {
+    name: { type: 'string', required: true, desc: '站点名称' },
+    customer: { type: 'string', desc: '所属客户 ID（data_scope != self 的账号必须传，如 owner/admin）' },
+    template: { type: 'string', desc: '模板 ID' },
+    domain: { type: 'string', desc: '主域名（可选，会真实绑定域名资源，谨慎使用）' },
+  },
+  async run(ctx) {
+    const { out, flags } = ctx;
+    const payload = { name: flags.name };
+    if (flags.customer) payload.customer_id = flags.customer;
+    if (flags.template) payload.template_id = flags.template;
+    if (flags.domain) payload.domains = [flags.domain];
+
+    let res;
+    try {
+      res = await ctx.callData('createSite', payload);
+    } catch (e) {
+      // 把"服务端 400 的一句话"翻译成"下一步怎么办"（这条错误很常见，值得专门处理）
+      if (e instanceof CliError && String(e.message || '').includes('无法确定所属客户')) {
+        e.hint =
+          '当前账号的 data_scope 不是 self（比如 owner/admin），服务端要求显式指定客户：' +
+          '加 `--customer <客户ID>` 重试（客户 ID 可在网页后台的客户列表里取）';
+      }
+      throw e;
+    }
+
+    const site = normalizeSite(res);
+    // 复核归属：owner_user_id 必须是当前登录用户（服务端就是这么写的，这里是"证据"）
+    let creds = null;
+    try {
+      creds = ctx.requireAuth();
+    } catch {
+      /* 拿不到也继续，只影响复核 */
+    }
+    const meId = creds && creds.account ? String(creds.account.sub || '') : '';
+    const ownerOk = !meId || site.owner_user_id === meId;
+    const data = { site, owner_matches_current_user: meId ? ownerOk : null, current_user_id: meId || null };
+
+    if (!out.json) {
+      out.ok(`站点已创建：${site.name}`);
+      out.line(`  站点 ID：${site.id}`);
+      out.line(`  状态：${site.status}`);
+      out.line(`  归属用户：${site.owner_user_id}${meId ? (ownerOk ? '（= 当前账号 ✔）' : `  ⚠️ 与当前账号 ${meId} 不一致，请核查`) : ''}`);
+    }
+    if (meId && !ownerOk) {
+      out.warn(`站点归属(${site.owner_user_id}) ≠ 当前账号(${meId})，请核查`);
+    }
+    ctx.done(data);
+    return data;
+  },
+};
+
+export const sitesDeleteCommand = {
+  name: 'sites delete',
+  summary: '删除站点（服务端是**软删除**：进回收站，可还原）',
+  usage: 'wkgeo sites delete <站点ID>',
+  args: [{ name: 'id', required: true, desc: '站点 ID' }],
+  async run(ctx) {
+    const { out } = ctx;
+    const id = ctx.positional.id;
+    const res = await ctx.callData('deleteSite', { id });
+    const data = { id, deleted: !!(res && res.deleted), soft: res ? res.soft !== false : true };
+    if (!out.json) {
+      out.ok(`站点已移入回收站（软删除，可在后台还原）：${id}`);
+      out.info('  注意：软删除不会释放域名等外部资源；彻底删除需要管理员在后台操作。');
+    }
+    ctx.done(data);
+    return data;
+  },
+};