@ws1298191366/cli 0.0.0-stage → 0.1.1

package/README.md

@@ -1,3 +1,70 @@
-# Temporary Holding Version
+# @jeecg/cli
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+在浏览器里授权登录 JeecgBoot / 敲敲云 / 积木报表，给 AI skills 提供 token，不用再从 F12 复制 `X-Access-Token`。
+
+需要 Node.js 18 以上，不依赖第三方包。
+
+## 取 token（一条命令）
+
+```bash
+jeecg auth token --host http://127.0.0.1:8080/jeecg-boot --type jeecgboot
+```
+
+- 已登录：直接输出 token；快过期时自动用 refresh_token 换新的
+- 没登录过，或者登录已过期 / 被撤销：自动打开默认浏览器进入授权页，没登录网页的先登录，确认账号（敲敲云还要选租户）后点「授权」，浏览器提示「授权成功」，命令输出 token
+- 第一次要给地址和产品标识，之后会记住，不用再带
+- 提示信息都打到 stderr，stdout 只有 token，所以脚本里直接这样用：
+
+```bash
+python xxx.py --api-base <地址> --token "$(jeecg auth token)"
+```
+
+token 由 shell 在执行时代入，不会出现在命令和对话记录里。自动授权时最多等 110 秒（AI 工具执行命令一般 2 分钟超时），超时会提示重新执行。
+
+## 产品标识 --type
+
+决定请求后端哪组接口：
+
+| --type | 产品 | --host 填什么 | 请求的接口 |
+|---|---|---|---|
+| `jeecgboot` | JeecgBoot | 后端地址，例如 `http://127.0.0.1:8080/jeecg-boot` | `{host}/.well-known/...`、`{host}/oauth2/token` |
+| `qiaoqiaoyun` | 敲敲云 | 同上（SaaS 为 `https://api.qiaoqiaoyun.com`） | 同上，和 JeecgBoot 是同一套后端 |
+| `jimureport` | 积木报表 | 应用地址，例如 `http://127.0.0.1:8085`（带不带 `/jmreport` 都行） | `{host}/jmreport/.well-known/...`、`{host}/jmreport/oauth2/token` |
+
+- 不填时按 jeecgboot、jimureport 的顺序自动探测；敲敲云和 JeecgBoot 后端一样探测不出来，要明确写 `--type qiaoqiaoyun`
+- 产品标识和登录信息存在一起，`jeecg auth status --json` 里的 `type` 字段就是它，skill 据此判断连的是哪个产品
+- 授权页地址由后端返回：JeecgBoot / 敲敲云的授权页在它们自己的前端（后端配置 `jeecg.domainUrl.pc`），积木的授权页在积木自己的页面
+
+## 其他命令
+
+```bash
+jeecg auth login [--host <地址>] [--type <产品>]   # 只登录（最多等 5 分钟），不输出 token
+jeecg auth complete "<浏览器地址栏里的地址>"          # 打不开浏览器时完成登录
+jeecg auth status --json                            # 本机登录状态：地址、产品、用户、租户（不输出 token）
+jeecg auth logout [--host <地址>]                   # 撤销授权并删除本机凭证
+```
+
+## 打不开浏览器时（SSH、没有图形界面的 Linux）
+
+- 在终端里：命令会打印授权链接，在自己电脑的浏览器里打开并点「授权」；浏览器跳回的 `127.0.0.1` 地址打不开，把地址栏里的完整地址粘贴回终端即可
+- 被 AI 调用（不在终端里）：命令打印授权链接后退出（退出码 2），用户授权后把地址栏的地址交给 `jeecg auth complete "<地址>"`（5 分钟内有效）；也可以加 `--manual` 主动这样做
+- 本机有浏览器但不想自动打开：加 `--no-open`
+
+## 服务器上的地址
+
+- `--host` 填前端调接口用的后端地址（nginx 转发后的外网地址，例如 `https://boot.example.com/jeecgboot`），换 token 也走这个地址
+- 后端要把 `jeecg.domainUrl.pc` 配成前端的外网地址，授权页地址是用它拼出来的；默认值是 `http://localhost:3100`，没改时 CLI 会提示
+- 授权后浏览器跳回的是你电脑上的 `127.0.0.1`，服务器不需要访问你的电脑，也不用开端口
+- 多个环境各登录一次，用 `--host` 切换，最后登录的是默认地址
+
+## 积木报表的宿主要求
+
+积木没有自己的用户体系，宿主要在 `JmReportTokenServiceI` 里实现 `createToken`（给 CLI 签发宿主认的 token），建议同时实现 `getLoginUrl`（没登录时跳哪）和 `revokeToken`（作废 token）；没实现 `createToken` 会提示「没有开启在线授权」。集成在 JeecgBoot 里的积木不用这套，用 `--type jeecgboot` 登录 JeecgBoot 地址即可，token 积木也认。
+
+## 凭证
+
+存在 `~/.jeecg/credentials.json`，按地址区分，文件权限 600。refresh_token（30 天有效、能换出新 token）加密保存：Windows 用系统自带的 DPAPI（密文和当前 Windows 账号绑定），macOS 存系统钥匙串，Linux 有 `secret-tool` 就存系统密钥环，没有时退回明文并提示；access_token 每次取 token 都要读，保持原样，取 token 不变慢。JeecgBoot / 敲敲云的 access_token 有效期和网页登录一样（84 小时），积木 2 小时；refresh_token 30 天，每次刷新换新的。
+
+## 后端要求
+
+JeecgBoot / 敲敲云要有 `/.well-known/oauth-authorization-server`、`/oauth2/token`、`/oauth2/revoke` 和前端授权页 `/oauth2/authorize`；积木要有 `/jmreport/` 下的同名接口（LHZP-2457）。老版本会提示「没有开启在线授权」。

package/bin/jeecg.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+'use strict';
+const auth = require('../lib/auth');
+
+const USAGE = `jeecg 命令行工具
+
+用法：
+  jeecg auth token [--host <地址>] [--type <产品>] [--scope <权限>] [--no-open] [--manual]
+      输出可用的 access_token，给脚本用：--token "$(jeecg auth token)"
+      快过期自动刷新；没登录过或登录已失效时自动打开浏览器授权，点「授权」后输出（提示信息打到 stderr，不影响取值）
+  jeecg auth login [--host <地址>] [--type <产品>] [--scope <权限>] [--no-open] [--manual]
+      只登录（最多等 5 分钟），不输出 token
+  jeecg auth complete "<浏览器地址栏里的地址>"
+      打不开浏览器时用：授权后浏览器会跳到一个打不开的 127.0.0.1 地址，把它交给这条命令完成登录
+  jeecg auth status [--host <地址>] [--json]
+      查看本机登录状态：地址、产品、用户、租户（不输出 token）
+  jeecg auth logout [--host <地址>]
+      撤销授权并删除本机凭证
+
+--type 产品标识，决定请求后端哪组接口：
+  jeecgboot     JeecgBoot，地址填后端地址，例如 http://127.0.0.1:8080/jeecg-boot
+  qiaoqiaoyun   敲敲云，和 JeecgBoot 同一套后端，地址同上（SaaS 为 https://api.qiaoqiaoyun.com）
+  jimureport    积木报表，地址填应用地址，例如 http://127.0.0.1:8085（带不带 /jmreport 都行）
+  不填时按 jeecgboot、jimureport 的顺序自动探测；敲敲云要明确写 --type qiaoqiaoyun
+
+打不开浏览器时（SSH、没有图形界面的 Linux）：
+  在终端里：把浏览器地址栏的地址粘贴回终端即可
+  被 AI 调用：命令打印授权链接后退出（退出码 2），用户授权后执行 jeecg auth complete "<地址>"；也可以加 --manual 主动这样做`;
+
+const VALUE_OPTIONS = ['host', 'scope', 'type'];
+
+function parseArgs(argv) {
+  const args = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const name = a.startsWith('--') ? a.slice(2).split('=')[0] : null;
+    if (a === '--no-open') {
+      args.open = false;
+    } else if (a === '--manual') {
+      args.manual = true;
+    } else if (a === '--json') {
+      args.json = true;
+    } else if (a === '-h' || a === '--help') {
+      args.help = true;
+    } else if (VALUE_OPTIONS.includes(name)) {
+      // 支持 --host x 和 --host=x 两种写法
+      args[name] = a.includes('=') ? a.slice(a.indexOf('=') + 1) : argv[++i];
+    } else {
+      args._.push(a);
+    }
+  }
+  return args;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const [group, cmd] = args._;
+  const commands = { login: auth.login, token: auth.token, complete: auth.complete, status: auth.status, logout: auth.logout };
+  const handler = group === 'auth' ? commands[cmd] : null;
+  if (args.help || !handler) {
+    console.log(USAGE);
+    process.exitCode = args.help ? 0 : 1;
+    return;
+  }
+  await handler(args);
+}
+
+main().catch((e) => {
+  console.error(e.message || e);
+  process.exitCode = 1;
+});

package/lib/auth.js

@@ -0,0 +1,552 @@
+'use strict';
+/**
+ * jeecg auth login / token / complete / status / logout
+ *
+ * 登录流程（OAuth2 授权码 + PKCE，和 Teambition CLI 的 auth login 一样）：
+ * 1. 按产品标识读后端的授权配置 .well-known/oauth-authorization-server，拿到授权页地址
+ * 2. 在本机 127.0.0.1 随机端口起一个回调服务，打开默认浏览器进入授权页
+ * 3. 用户在页面上点「授权」后，浏览器带着授权码跳回回调地址
+ * 4. 用授权码 + code_verifier 换 token，存到 ~/.jeecg/credentials.json（refresh_token 加密，见 secret.js）
+ *
+ * 打不开本机浏览器时（SSH、没有图形界面的 Linux）：在终端里可以把浏览器地址栏的地址粘贴回来；
+ * 被 AI 调用（不在终端里）时打印链接后退出，用户授权后把地址栏的地址交给 jeecg auth complete
+ *
+ * 输出约定：stdout 只放给程序用的结果（token、status --json），提示信息一律打到 stderr，
+ * 这样 --token "$(jeecg auth token)" 里就算触发了登录，拿到的也只有 token
+ */
+const crypto = require('crypto');
+const http = require('http');
+const readline = require('readline');
+const { spawn } = require('child_process');
+const store = require('./store');
+const secret = require('./secret');
+
+/** 后端内置的公共客户端，没有 secret，靠 PKCE 防止授权码被截获后冒用 */
+const CLIENT_ID = 'jeecg-cli';
+/** 手动执行 jeecg auth login 时，等用户点授权最多 5 分钟（和后端授权码有效期一致） */
+const LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
+/** jeecg auth token 自动登录时只等 110 秒：AI 工具执行命令默认 2 分钟超时，先自己超时退出、给出提示，别被直接杀掉 */
+const AUTO_LOGIN_TIMEOUT_MS = 110 * 1000;
+/** access_token 还剩 5 分钟就提前刷新 */
+const REFRESH_AHEAD_MS = 5 * 60 * 1000;
+/** 打不开浏览器、改成 jeecg auth complete 完成授权时的退出码，调用方据此知道这次没拿到 token */
+const MANUAL_EXIT_CODE = 2;
+const HOST_EXAMPLE = 'JeecgBoot / 敲敲云 http://127.0.0.1:8080/jeecg-boot，积木报表 http://127.0.0.1:8085';
+
+/**
+ * 产品标识（--type），决定请求后端哪组接口：
+ * - jeecgboot、qiaoqiaoyun：同一套后端，接口在后端地址下，例如 http://127.0.0.1:8080/jeecg-boot/oauth2/token；
+ *   标识用来区分产品，skill 从 jeecg auth status --json 里的 type 知道连的是谁
+ * - jimureport：积木是嵌在宿主应用里的，接口挂在 /jmreport 下，例如 http://127.0.0.1:8085/jmreport/oauth2/token
+ */
+const PRODUCTS = {
+  jeecgboot: { name: 'JeecgBoot', prefix: '' },
+  qiaoqiaoyun: { name: '敲敲云', prefix: '' },
+  jimureport: { name: '积木报表', prefix: '/jmreport' },
+};
+/** 没给 --type 时的探测顺序；敲敲云和 JeecgBoot 后端一样探测不出来，要用 --type qiaoqiaoyun 标明 */
+const DETECT_ORDER = ['jeecgboot', 'jimureport'];
+
+async function login(args) {
+  const { host, type } = await resolveTarget(args, true);
+  const cred = await browserLogin(host, type, args, LOGIN_TIMEOUT_MS);
+  if (cred) {
+    console.error(successText(cred));
+  }
+}
+
+/**
+ * 输出可用的 access_token（给脚本用：--token "$(jeecg auth token)"），一条命令把取 token 的几种情况都处理掉：
+ * 1. 已登录且没过期：直接输出
+ * 2. 快过期：用 refresh_token 换新的
+ * 3. 没登录过，或者登录已过期 / 被撤销：自动打开浏览器授权，用户点「授权」后输出
+ */
+async function token(args) {
+  const { host, type } = await resolveTarget(args, true);
+  const cred = store.load().hosts[host];
+  if (cred && Date.now() < cred.expiresAt - REFRESH_AHEAD_MS) {
+    process.stdout.write(cred.accessToken + '\n');
+    return;
+  }
+  const refreshed = cred ? await refresh(host, cred) : null;
+  if (refreshed) {
+    process.stdout.write(refreshed.accessToken + '\n');
+    return;
+  }
+  console.error(cred ? `登录已过期或已被撤销（${host}），重新授权：` : `还没有登录 ${host}，开始授权：`);
+  const fresh = await browserLogin(host, type || (cred && cred.type), args, AUTO_LOGIN_TIMEOUT_MS);
+  if (!fresh) {
+    // 打不开浏览器：已经打印了授权链接，等 jeecg auth complete，这次不输出 token
+    return;
+  }
+  console.error(successText(fresh));
+  process.stdout.write(fresh.accessToken + '\n');
+}
+
+/**
+ * 用浏览器地址栏里的回调地址完成授权：配合 jeecg auth login --manual，或者打不开浏览器时自动打印的链接
+ */
+async function complete(args) {
+  const callbackUrl = args._[2];
+  const pending = store.loadPending();
+  if (!pending || Date.now() > pending.expiresAt) {
+    throw new Error('没有待完成的授权，或者已经超过 5 分钟，请重新执行 jeecg auth login --manual');
+  }
+  if (!callbackUrl) {
+    throw new Error('用法：jeecg auth complete "<浏览器地址栏里的地址>"');
+  }
+  const code = parseCallback(callbackUrl, pending.state);
+  const cred = await exchangeCode(pending, code);
+  store.clearPending();
+  console.error(successText(cred));
+}
+
+/**
+ * 只看本机保存的登录信息，不输出 token；--json 给程序读地址、产品和租户
+ */
+async function status(args) {
+  const data = store.load();
+  const hosts = args.host ? [(await resolveTarget(args, false)).host] : Object.keys(data.hosts);
+  const list = hosts
+    .filter((h) => data.hosts[h])
+    .map((h) => ({
+      host: h,
+      type: typeOf(data.hosts[h]),
+      username: data.hosts[h].username,
+      tenant_id: data.hosts[h].tenantId,
+      default: h === data.defaultHost,
+    }));
+  if (args.json) {
+    console.log(JSON.stringify({ logged_in: list.length > 0, default_host: data.defaultHost, hosts: list }, null, 2));
+    return;
+  }
+  if (list.length === 0) {
+    console.log('还没有登录，请执行：jeecg auth login --host <地址> --type <jeecgboot|qiaoqiaoyun|jimureport>');
+    process.exitCode = 1;
+    return;
+  }
+  for (const c of list) {
+    console.log(`${c.default ? '* ' : '  '}${c.host}  ${PRODUCTS[c.type].name}  用户 ${c.username}${c.tenant_id != null ? `  租户 ${c.tenant_id}` : ''}`);
+  }
+}
+
+async function logout(args) {
+  const { host } = await resolveTarget(args, false);
+  const data = store.load();
+  const cred = data.hosts[host];
+  if (!cred) {
+    console.log(`本机没有 ${host} 的登录信息`);
+    return;
+  }
+  const refreshToken = secret.unprotect(host, cred.refreshToken);
+  if (refreshToken) {
+    try {
+      await fetch(cred.revocationEndpoint, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: new URLSearchParams({ token: refreshToken, client_id: CLIENT_ID }),
+      });
+    } catch (e) {
+      console.log(`服务器撤销失败（${e.message}），只删除了本机凭证`);
+    }
+  }
+  secret.remove(host, cred.refreshToken);
+  delete data.hosts[host];
+  if (data.defaultHost === host) {
+    data.defaultHost = Object.keys(data.hosts)[0] || null;
+  }
+  store.save(data);
+  console.log(`已退出 ${host}`);
+}
+
+/**
+ * 浏览器授权登录，成功后保存凭证并设为默认地址；打不开浏览器又不在终端里时返回 null（改由 jeecg auth complete 完成）
+ */
+async function browserLogin(host, type, args, timeoutMs) {
+  // 1. 按产品标识请求对应的授权配置；没给标识时按 DETECT_ORDER 依次探测
+  let meta = null;
+  for (const t of type ? [type] : DETECT_ORDER) {
+    meta = await fetchMetadata(host, PRODUCTS[t].prefix);
+    if (meta) {
+      type = t;
+      break;
+    }
+  }
+  if (!meta) {
+    throw new Error(notEnabledText(host, type));
+  }
+  // 换 token、撤销直接用用户给的地址拼：nginx 常把外网 /jeecgboot 转发到后端 /jeecg-boot，
+  // 后端按请求算出来的 token_endpoint（.../jeecg-boot/oauth2/token）在外网访问不到
+  const base = host + PRODUCTS[type].prefix;
+  const login = {
+    host,
+    type,
+    verifier: crypto.randomBytes(32).toString('base64url'),
+    state: crypto.randomBytes(16).toString('base64url'),
+    tokenEndpoint: `${base}/oauth2/token`,
+    revocationEndpoint: `${base}/oauth2/revoke`,
+  };
+  warnLocalAuthorizePage(meta.authorization_endpoint, host);
+
+  // 2. 打不开本机浏览器又不在终端里（例如 AI 在服务器上调用）：打印链接后退出，等 jeecg auth complete
+  if (args.manual || (!process.stdin.isTTY && !hasLocalBrowser())) {
+    login.redirectUri = `http://127.0.0.1:${await freePort()}/callback`;
+    login.expiresAt = Date.now() + LOGIN_TIMEOUT_MS;
+    store.savePending(login);
+    console.error(`请在自己电脑的浏览器里打开下面的链接，确认授权（${PRODUCTS[type].name}，5 分钟内有效）：\n${authorizeUrl(meta, login, args.scope)}\n`);
+    console.error('授权后浏览器会跳到一个打不开的 127.0.0.1 地址，把地址栏里的完整地址交给：jeecg auth complete "<地址>"');
+    process.exitCode = MANUAL_EXIT_CODE;
+    return null;
+  }
+
+  // 3. 本机起回调服务，打开授权页
+  const callback = await startCallbackServer(login.state);
+  login.redirectUri = `http://127.0.0.1:${callback.port}/callback`;
+  console.error(`请在浏览器中确认授权（${PRODUCTS[type].name}）：\n${authorizeUrl(meta, login, args.scope)}\n`);
+  const browserOpened = args.open !== false && hasLocalBrowser();
+  if (browserOpened) {
+    openBrowser(authorizeUrl(meta, login, args.scope));
+  }
+  // 在终端里又没自动打开浏览器（--no-open、SSH）：浏览器跳回时可能打不开，也可以把地址栏的地址粘贴回来
+  const paste = !browserOpened && process.stdin.isTTY ? waitForPaste(login.state) : null;
+
+  // 4. 等用户点「授权」，用授权码换 token
+  let code;
+  try {
+    code = await (paste ? Promise.race([callback.waitForCode(timeoutMs), paste.promise]) : callback.waitForCode(timeoutMs));
+  } finally {
+    callback.close();
+    if (paste) {
+      paste.close();
+    }
+  }
+  return exchangeCode(login, code);
+}
+
+/**
+ * 用授权码 + code_verifier 换 token，保存凭证并设为默认地址
+ */
+async function exchangeCode(login, code) {
+  const t = await requestToken(login.tokenEndpoint, {
+    grant_type: 'authorization_code',
+    code,
+    code_verifier: login.verifier,
+    redirect_uri: login.redirectUri,
+    client_id: CLIENT_ID,
+  });
+  const data = store.load();
+  data.hosts[login.host] = toCredential(t, login.host, login.type, login.tokenEndpoint, login.revocationEndpoint);
+  data.defaultHost = login.host;
+  store.save(data);
+  return data.hosts[login.host];
+}
+
+/**
+ * 用 refresh_token 换新 token；登录已过期、被撤销或 refresh_token 解不开时返回 null（由调用方重新授权）
+ */
+async function refresh(host, cred) {
+  const refreshToken = secret.unprotect(host, cred.refreshToken);
+  if (!refreshToken) {
+    return null;
+  }
+  try {
+    const t = await requestToken(cred.tokenEndpoint, { grant_type: 'refresh_token', refresh_token: refreshToken, client_id: CLIENT_ID });
+    const data = store.load();
+    data.hosts[host] = toCredential(t, host, typeOf(cred), cred.tokenEndpoint, cred.revocationEndpoint);
+    store.save(data);
+    return data.hosts[host];
+  } catch (e) {
+    if (e.oauthError !== 'invalid_grant') {
+      throw e;
+    }
+    // refresh_token 每次刷新都会换新的：两个脚本同时刷新时后到的会失败，先看看另一个进程是不是已经刷新好了
+    // （比 accessToken：refresh_token 存进钥匙串时记录里只有 keychain: 标记，前后一样，比不出来）
+    await new Promise((r) => setTimeout(r, 1000));
+    const latest = store.load().hosts[host];
+    return latest && latest.accessToken !== cred.accessToken ? latest : null;
+  }
+}
+
+/**
+ * 地址和产品标识：--host 优先，其次上次登录的地址；都没有时在终端里提示输入（第一次使用）
+ */
+async function resolveTarget(args, allowPrompt) {
+  const type = args.type || null;
+  if (type && !PRODUCTS[type]) {
+    throw new Error(`不认识的 --type：${type}，可选 ${Object.keys(PRODUCTS).join(' / ')}`);
+  }
+  let host;
+  if (args.host) {
+    host = normalizeHost(args.host);
+  } else {
+    const data = store.load();
+    if (data.defaultHost) {
+      host = data.defaultHost;
+    } else if (allowPrompt && process.stdin.isTTY) {
+      host = normalizeHost(await prompt(`请输入地址（${HOST_EXAMPLE}）：`));
+    } else {
+      throw new Error(`还没有登录过，请用 --host 指定地址（${HOST_EXAMPLE}）`);
+    }
+  }
+  // 积木地址常带着 /jmreport（例如 skill 用的 http://127.0.0.1:8085/jmreport），统一存应用地址，接口前缀按标识拼；
+  // 不写 --type 时照常探测：集成在 JeecgBoot 里的积木（.../jeecg-boot/jmreport）会识别成 jeecgboot，token 积木也认
+  if (/\/jmreport$/i.test(host) && type !== 'jeecgboot' && type !== 'qiaoqiaoyun') {
+    host = host.slice(0, -'/jmreport'.length);
+  }
+  return { host, type };
+}
+
+function normalizeHost(host) {
+  const h = String(host || '').trim().replace(/\/+$/, '');
+  if (!/^https?:\/\/[^/]+/i.test(h)) {
+    throw new Error(`地址要以 http:// 或 https:// 开头（${HOST_EXAMPLE}）`);
+  }
+  return h;
+}
+
+/**
+ * 读授权配置；连不上直接报错，接口不存在（老版本、不是这个产品、宿主没开启）返回 null
+ */
+async function fetchMetadata(host, prefix) {
+  let res;
+  try {
+    res = await fetch(`${host}${prefix}/.well-known/oauth-authorization-server`);
+  } catch (e) {
+    throw new Error(`连不上 ${host}：${(e.cause && e.cause.code) || e.message}`);
+  }
+  // 可能是 404，也可能被 Shiro 拦成 401（Token失效），前端开发服务器还会返回 index.html
+  const meta = await res.json().catch(() => ({}));
+  return res.ok && meta.authorization_endpoint && meta.token_endpoint ? meta : null;
+}
+
+function authorizeUrl(meta, login, scope) {
+  const params = new URLSearchParams({
+    response_type: 'code',
+    client_id: CLIENT_ID,
+    redirect_uri: login.redirectUri,
+    code_challenge: crypto.createHash('sha256').update(login.verifier).digest('base64url'),
+    code_challenge_method: 'S256',
+    state: login.state,
+  });
+  if (scope) {
+    params.set('scope', scope);
+  }
+  return `${meta.authorization_endpoint}?${params}`;
+}
+
+/**
+ * 解析浏览器地址栏里的回调地址，例如 http://127.0.0.1:52345/callback?code=xxx&state=xxx
+ */
+function parseCallback(text, expectedState) {
+  let url;
+  try {
+    url = new URL(String(text).trim());
+  } catch (e) {
+    throw new Error('粘贴的不是完整地址，应该形如 http://127.0.0.1:端口/callback?code=...&state=...');
+  }
+  if (url.searchParams.get('error')) {
+    throw new Error('已在浏览器中取消授权');
+  }
+  if (url.searchParams.get('state') !== expectedState) {
+    throw new Error('地址里的 state 和这次授权对不上，可能粘贴了别的授权链接');
+  }
+  const code = url.searchParams.get('code');
+  if (!code) {
+    throw new Error('地址里没有授权码');
+  }
+  return code;
+}
+
+/**
+ * 在终端里等用户粘贴回调地址（和本机回调服务同时等，哪个先到用哪个）
+ */
+function waitForPaste(expectedState) {
+  console.error('如果浏览器跳回时打不开页面（比如在 SSH 服务器上），把浏览器地址栏里的完整地址粘贴到这里，回车：');
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr, terminal: false });
+  const promise = new Promise((resolve, reject) => {
+    rl.on('line', (line) => {
+      if (!line.trim()) {
+        return;
+      }
+      try {
+        resolve(parseCallback(line, expectedState));
+      } catch (e) {
+        reject(e);
+      }
+    });
+  });
+  promise.catch(() => {});
+  return { promise, close: () => rl.close() };
+}
+
+/**
+ * SSH 会话、没有图形界面的 Linux 打不开本机浏览器（和 claude mcp login 的判断一样）
+ */
+function hasLocalBrowser() {
+  if (process.env.SSH_CONNECTION || process.env.SSH_TTY) {
+    return false;
+  }
+  return !(process.platform === 'linux' && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY);
+}
+
+function freePort() {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer();
+    server.on('error', reject);
+    server.listen(0, '127.0.0.1', () => {
+      const port = server.address().port;
+      server.close(() => resolve(port));
+    });
+  });
+}
+
+function notEnabledText(host, type) {
+  if (type === 'jimureport') {
+    return `${host} 的积木报表没有开启在线授权：独立部署要宿主实现 JmReportTokenServiceI.createToken；集成在 JeecgBoot 里的积木请用 --type jeecgboot 登录 JeecgBoot 地址`;
+  }
+  return `${host} 没有开启在线授权：后端版本太旧，或者地址 / --type 不对（${HOST_EXAMPLE}）`;
+}
+
+function successText(cred) {
+  return `登录成功（${PRODUCTS[typeOf(cred)].name}）：${cred.username}${cred.tenantId != null ? `，租户 ${cred.tenantId}` : ''}`;
+}
+
+/** 以前存的凭证没有 type，都是 JeecgBoot 地址 */
+function typeOf(cred) {
+  return PRODUCTS[cred.type] ? cred.type : 'jeecgboot';
+}
+
+/**
+ * 授权页地址来自后端配置 jeecg.domainUrl.pc，默认是 http://localhost:3100；部署到服务器没改的话，浏览器会打开本机地址
+ */
+function warnLocalAuthorizePage(authorizeEndpoint, host) {
+  const isLocal = (u) => /^https?:\/\/(localhost|127\.0\.0\.1)(:|\/|$)/i.test(u);
+  if (isLocal(authorizeEndpoint) && !isLocal(host)) {
+    const origin = new URL(authorizeEndpoint).origin;
+    console.error(`注意：后端返回的授权页是 ${origin}，服务器上可能没配置 jeecg.domainUrl.pc（要配成前端的外网地址）。`);
+    console.error(`临时办法：把下面链接里的 ${origin} 换成前端地址，再在浏览器里打开。\n`);
+  }
+}
+
+async function requestToken(endpoint, form) {
+  const res = await fetch(endpoint, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    body: new URLSearchParams(form),
+  });
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok || !body.access_token) {
+    // OAuth 错误在 error_description 里；后端抛异常时走的是 JeecgBoot 的 Result 格式，原因在 message 里
+    const err = new Error(`换取 token 失败：${body.error_description || body.error || body.message || `HTTP ${res.status}`}`);
+    err.oauthError = body.error;
+    throw err;
+  }
+  return body;
+}
+
+function toCredential(t, host, type, tokenEndpoint, revocationEndpoint) {
+  return {
+    type,
+    username: t.username,
+    tenantId: t.tenant_id == null ? null : t.tenant_id,
+    scope: t.scope || null,
+    accessToken: t.access_token,
+    refreshToken: secret.protect(host, t.refresh_token),
+    expiresAt: Date.now() + Number(t.expires_in || 0) * 1000,
+    tokenEndpoint,
+    revocationEndpoint,
+  };
+}
+
+/**
+ * 本机回调服务：只监听 127.0.0.1，state 对不上的请求直接忽略（不是这次登录发起的）
+ */
+function startCallbackServer(expectedState) {
+  let settle;
+  const result = new Promise((resolve, reject) => {
+    settle = { resolve, reject };
+  });
+  // 失败由 waitForCode 返回给调用方，这里只是避免回调早于 waitForCode 时报 unhandled rejection
+  result.catch(() => {});
+  const server = http.createServer((req, res) => {
+    const url = new URL(req.url, 'http://127.0.0.1');
+    if (url.pathname !== '/callback' || url.searchParams.get('state') !== expectedState) {
+      res.writeHead(404, { Connection: 'close' });
+      res.end();
+      return;
+    }
+    if (url.searchParams.get('error')) {
+      sendPage(res, '已取消授权', '你在浏览器中取消了授权，可以关闭此页面。');
+      settle.reject(new Error('已在浏览器中取消授权'));
+      return;
+    }
+    const code = url.searchParams.get('code');
+    if (!code) {
+      sendPage(res, '授权失败', '回调里没有授权码，请回到终端重新登录。');
+      settle.reject(new Error('回调里没有授权码'));
+      return;
+    }
+    sendPage(res, '授权成功', 'jeecg CLI 已完成授权，现在可以关闭此页面，返回终端继续使用。');
+    settle.resolve(code);
+  });
+  return new Promise((resolve, reject) => {
+    server.on('error', reject);
+    server.listen(0, '127.0.0.1', () => {
+      resolve({
+        port: server.address().port,
+        waitForCode(timeoutMs) {
+          const timer = setTimeout(() => settle.reject(new Error(`等待授权超时（${Math.round(timeoutMs / 1000)} 秒），请重新执行`)), timeoutMs);
+          return result.finally(() => clearTimeout(timer));
+        },
+        close() {
+          server.close();
+          // 浏览器会保持长连接，不断开的话进程要等几秒才退出
+          if (server.closeAllConnections) {
+            server.closeAllConnections();
+          }
+        },
+      });
+    });
+  });
+}
+
+function sendPage(res, title, message) {
+  res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8', Connection: 'close' });
+  res.end(`<!DOCTYPE html><html><head><meta charset="utf-8"><title>jeecg CLI ${title}</title></head>
+<body style="margin:0;background:#f5f7fa;font-family:sans-serif;display:flex;align-items:center;justify-content:center;min-height:100vh">
+<div style="background:#fff;border-radius:8px;box-shadow:0 4px 24px rgba(0,0,0,.08);padding:40px 56px;text-align:center">
+<h2 style="margin:0 0 12px">${title}</h2><div style="color:#8c8c8c">${message}</div></div></body></html>`);
+}
+
+function openBrowser(url) {
+  // Windows 不走 cmd /c start：URL 里的 & 会被 cmd 当成命令分隔符截断
+  const [cmd, cmdArgs] =
+    process.platform === 'win32'
+      ? ['rundll32', ['url.dll,FileProtocolHandler', url]]
+      : process.platform === 'darwin'
+      ? ['open', [url]]
+      : ['xdg-open', [url]];
+  const tip = () => console.error('没能自动打开浏览器，请手动复制上面的链接到浏览器打开');
+  try {
+    const child = spawn(cmd, cmdArgs, { stdio: 'ignore', detached: true });
+    child.on('error', tip);
+    child.unref();
+  } catch (e) {
+    tip();
+  }
+}
+
+/**
+ * 提示打到 stderr：在 $(jeecg auth token) 里第一次使用时，stdout 会被当成 token 收走
+ */
+function prompt(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) =>
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    })
+  );
+}
+
+module.exports = { login, token, complete, status, logout };

package/lib/secret.js

@@ -0,0 +1,89 @@
+'use strict';
+/**
+ * refresh_token 加密存储：它 30 天有效、能换出新 token，是本机凭证里最要紧的。
+ * access_token 有效期短，而且每次 jeecg auth token 都要读，保持原样，取 token 不变慢。
+ *
+ * - Windows：DPAPI，系统自带，密文和当前 Windows 账号绑定（拷到别的电脑或账号解不开）；通过 PowerShell 调用，一次约 0.35 秒
+ * - macOS：系统钥匙串（security 命令）
+ * - Linux：有 secret-tool 就存进系统密钥环；没有（服务器上常见）或调用失败，就退回明文（文件权限 600）并提示
+ *
+ * credentials.json 里存的值带前缀说明存在哪：dpapi:<密文> / keychain: / secret-tool: ；没有前缀的是明文（以前存的或退回明文的）
+ */
+const { execFileSync } = require('child_process');
+
+const SERVICE = 'jeecg-cli';
+// 明文和密文都从环境变量传给 PowerShell，不出现在进程命令行里
+const PROTECT_PS =
+  "Add-Type -AssemblyName System.Security;[Convert]::ToBase64String([Security.Cryptography.ProtectedData]::Protect([Text.Encoding]::UTF8.GetBytes($env:JEECG_SECRET),$null,'CurrentUser'))";
+const UNPROTECT_PS =
+  "Add-Type -AssemblyName System.Security;[Text.Encoding]::UTF8.GetString([Security.Cryptography.ProtectedData]::Unprotect([Convert]::FromBase64String($env:JEECG_SECRET),$null,'CurrentUser'))";
+
+function protect(host, secret) {
+  if (!secret) {
+    return secret;
+  }
+  try {
+    if (process.platform === 'win32') {
+      return 'dpapi:' + powershell(PROTECT_PS, secret);
+    }
+    if (process.platform === 'darwin') {
+      // security -i 从标准输入读命令，密钥不出现在进程命令行里
+      execFileSync('security', ['-i'], { input: `add-generic-password -U -a "${host}" -s "${SERVICE}" -w "${secret}"\n`, stdio: ['pipe', 'ignore', 'pipe'] });
+      return 'keychain:';
+    }
+    execFileSync('secret-tool', ['store', `--label=jeecg CLI ${host}`, 'service', SERVICE, 'account', host], { input: secret, stdio: ['pipe', 'ignore', 'pipe'] });
+    return 'secret-tool:';
+  } catch (e) {
+    console.error(`提示：本机没有可用的系统密钥存储（${e.code || e.message}），refresh_token 以明文保存在 ~/.jeecg/credentials.json（文件权限 600）`);
+    return secret;
+  }
+}
+
+/**
+ * 取回明文；解不开（换了电脑或账号、钥匙串里被删了）返回 null，调用方按「没有 refresh_token」处理，重新授权
+ */
+function unprotect(host, stored) {
+  if (!stored) {
+    return null;
+  }
+  try {
+    if (stored.startsWith('dpapi:')) {
+      return powershell(UNPROTECT_PS, stored.slice('dpapi:'.length));
+    }
+    if (stored === 'keychain:') {
+      return execFileSync('security', ['find-generic-password', '-a', host, '-s', SERVICE, '-w'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+    }
+    if (stored === 'secret-tool:') {
+      return execFileSync('secret-tool', ['lookup', 'service', SERVICE, 'account', host], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+    }
+  } catch (e) {
+    return null;
+  }
+  return stored;
+}
+
+/**
+ * 退出时把钥匙串 / 密钥环里的那份也删掉（DPAPI 和明文都在 credentials.json 里，删记录就没了）
+ */
+function remove(host, stored) {
+  try {
+    if (stored === 'keychain:') {
+      execFileSync('security', ['delete-generic-password', '-a', host, '-s', SERVICE], { stdio: 'ignore' });
+    } else if (stored === 'secret-tool:') {
+      execFileSync('secret-tool', ['clear', 'service', SERVICE, 'account', host], { stdio: 'ignore' });
+    }
+  } catch (e) {
+    // 本来就没有，不用处理
+  }
+}
+
+function powershell(script, input) {
+  return execFileSync('powershell', ['-NoProfile', '-NonInteractive', '-Command', script], {
+    env: { ...process.env, JEECG_SECRET: input },
+    encoding: 'utf8',
+    windowsHide: true,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  }).trim();
+}
+
+module.exports = { protect, unprotect, remove };

package/lib/store.js

@@ -0,0 +1,56 @@
+'use strict';
+/**
+ * 本机凭证：按地址存在 ~/.jeecg/credentials.json（文件权限 600）
+ * 结构：{ defaultHost, hosts: { "<地址>": { type, username, tenantId, accessToken, refreshToken, expiresAt, ... } } }
+ *
+ * 待完成的授权（jeecg auth login --manual 打印链接后退出、等 jeecg auth complete）存在 ~/.jeecg/pending.json，5 分钟有效
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const DIR = path.join(os.homedir(), '.jeecg');
+const FILE = path.join(DIR, 'credentials.json');
+const PENDING_FILE = path.join(DIR, 'pending.json');
+
+function load() {
+  try {
+    const data = JSON.parse(fs.readFileSync(FILE, 'utf8'));
+    return { defaultHost: data.defaultHost || null, hosts: data.hosts || {} };
+  } catch (e) {
+    return { defaultHost: null, hosts: {} };
+  }
+}
+
+function save(data) {
+  writePrivate(FILE, data);
+}
+
+function loadPending() {
+  try {
+    return JSON.parse(fs.readFileSync(PENDING_FILE, 'utf8'));
+  } catch (e) {
+    return null;
+  }
+}
+
+function savePending(pending) {
+  writePrivate(PENDING_FILE, pending);
+}
+
+function clearPending() {
+  try {
+    fs.unlinkSync(PENDING_FILE);
+  } catch (e) {
+    // 本来就没有
+  }
+}
+
+function writePrivate(file, data) {
+  fs.mkdirSync(DIR, { recursive: true, mode: 0o700 });
+  fs.writeFileSync(file, JSON.stringify(data, null, 2), { mode: 0o600 });
+  // 文件已存在时 writeFileSync 不会改权限，这里再收紧一次（Windows 上由用户目录的 ACL 保护）
+  fs.chmodSync(file, 0o600);
+}
+
+module.exports = { load, save, loadPending, savePending, clearPending, FILE };

package/package.json

@@ -1,6 +1,20 @@
 {
   "name": "@ws1298191366/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "JEECG 命令行工具：在浏览器里授权登录 JeecgBoot / 敲敲云，给 AI skills 提供 token",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "bin": {
+    "jeecg": "bin/jeecg.js"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}