@ws1298191366/cli 0.1.1 → 0.1.3

package/README.md

@@ -1,6 +1,6 @@
 # @jeecg/cli
 
-在浏览器里授权登录 JeecgBoot / 敲敲云 / 积木报表，给 AI skills 提供 token，不用再从 F12 复制 `X-Access-Token`。
+在浏览器里登录 JeecgBoot / 敲敲云 / 积木报表，给 AI skills 提供 token，不用再从 F12 复制 `X-Access-Token`。
 
 需要 Node.js 18 以上，不依赖第三方包。
 
@@ -11,7 +11,9 @@ jeecg auth token --host http://127.0.0.1:8080/jeecg-boot --type jeecgboot
 ```
 
 - 已登录：直接输出 token；快过期时自动用 refresh_token 换新的
-- 没登录过，或者登录已过期 / 被撤销：自动打开默认浏览器进入授权页，没登录网页的先登录，确认账号（敲敲云还要选租户）后点「授权」，浏览器提示「授权成功」，命令输出 token
+- 没登录过，或者登录已过期 / 被撤销：自动打开浏览器登录，完成后命令输出 token
+  - JeecgBoot / 敲敲云：CLI 在本机起一个登录页，输入账号、密码、验证码，确认租户后点「授权」
+  - 积木报表：打开积木自己的授权页，没登录时先跳到宿主系统的登录页，登录后点「授权」
 - 第一次要给地址和产品标识，之后会记住，不用再带
 - 提示信息都打到 stderr，stdout 只有 token，所以脚本里直接这样用：
 
@@ -19,7 +21,7 @@ jeecg auth token --host http://127.0.0.1:8080/jeecg-boot --type jeecgboot
 python xxx.py --api-base <地址> --token "$(jeecg auth token)"
 ```
 
-token 由 shell 在执行时代入，不会出现在命令和对话记录里。自动授权时最多等 110 秒（AI 工具执行命令一般 2 分钟超时），超时会提示重新执行。
+token 由 shell 在执行时代入，不会出现在命令和对话记录里。自动登录时最多等 110 秒（AI 工具执行命令一般 2 分钟超时），超时会提示重新执行。
 
 ## 产品标识 --type
 
@@ -33,28 +35,56 @@ token 由 shell 在执行时代入，不会出现在命令和对话记录里。
 
 - 不填时按 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 login [--host <地址>] [--type <产品>]   # 只登录（最多等 5 分钟），不输出 token；已登录时直接确认租户，页面上可以切换账号
 jeecg auth status --json                            # 本机登录状态：地址、产品、用户、租户（不输出 token）
 jeecg auth logout [--host <地址>]                   # 撤销授权并删除本机凭证
+jeecg auth complete "<浏览器地址栏里的地址>"          # 积木报表打不开浏览器时完成登录
 ```
 
-## 打不开浏览器时（SSH、没有图形界面的 Linux）
+## 登录页（JeecgBoot / 敲敲云）
 
-- 在终端里：命令会打印授权链接，在自己电脑的浏览器里打开并点「授权」；浏览器跳回的 `127.0.0.1` 地址打不开，把地址栏里的完整地址粘贴回终端即可
-- 被 AI 调用（不在终端里）：命令打印授权链接后退出（退出码 2），用户授权后把地址栏的地址交给 `jeecg auth complete "<地址>"`（5 分钟内有效）；也可以加 `--manual` 主动这样做
+- 页面由 CLI 在本机 `127.0.0.1` 随机端口提供，不依赖 vue3 前端，后端也不用配置前端地址
+- 验证码用原来的 `/sys/randomImage/{key}`，要不要验证码跟系统的 `jeecg.firewall.enableLoginCaptcha` 开关走；登录失败次数和网页登录共用（失败 5 次锁 10 分钟）
+- 签发的是 CLI 专用的 token，不会把浏览器里的登录顶掉，开了「禁止多地登录」也一样
+- 租户只记在本机（`jeecg auth status` 能看到），skill 调接口时用它做请求头 `X-Tenant-Id`；换租户再执行一次 `jeecg auth login`
+- 地址里带随机串，只接受页面自己发的请求，别的网页操作不了；账号密码只在本机和后端之间传
+
+## 打不开浏览器时（SSH 登录的服务器、没有图形界面的 Linux）
+
+- JeecgBoot / 敲敲云：执行 `jeecg auth login`，它会打印登录页地址，在你自己电脑的浏览器里打开
+  - VS Code、Cursor 等远程连接会自动转发端口，直接点开链接即可
+  - 普通 SSH：先在自己电脑上执行 `ssh -L <端口>:127.0.0.1:<端口> <用户>@<服务器>`，再打开链接
+  - 被 AI 调用时，`jeecg auth token` 直接打印提示并退出（退出码 2）：AI 改为在后台执行 `jeecg auth login`，把登录页地址发给用户
+- 积木报表：命令打印授权链接，在自己电脑的浏览器里打开并点「授权」；浏览器跳回的 `127.0.0.1` 地址打不开，把地址栏里的完整地址粘贴回终端即可。被 AI 调用时命令打印链接后退出（退出码 2），用户授权后把地址栏的地址交给 `jeecg auth complete "<地址>"`（5 分钟内有效）；也可以加 `--manual` 主动这样做
 - 本机有浏览器但不想自动打开：加 `--no-open`
 
+## Windows PowerShell
+
+PowerShell 里执行 `jeecg` 报「无法加载文件 ...\jeecg.ps1，因为在此系统上禁止运行脚本」时，执行一次：
+
+```powershell
+Set-ExecutionPolicy -Scope CurrentUser RemoteSigned
+```
+
+只对当前用户生效，npm 全局装的 pnpm、yarn 等命令也需要这一步。不想改的话，用 `jeecg.cmd` 代替 `jeecg`。Git Bash、cmd 和 Python 的 `subprocess(..., shell=True)` 不受影响。
+
+## macOS / Linux / WSL
+
+- 安装报 `EACCES`：Node 装在系统目录时（Linux 用 apt 装的、macOS 用官网安装包装的）全局安装要权限，用 `sudo npm i -g @jeecg/cli`，或者用 nvm 装 Node（不用 sudo）
+- Node 版本：Linux 发行版自带的 Node 常常低于 18（例如 Ubuntu 22.04 的 apt 装的是 12），`jeecg` 会直接提示升级
+- 打开浏览器：macOS 用 `open`，Linux 桌面用 `xdg-open`；没装 xdg-utils 或打不开时会提示，复制链接到浏览器打开即可
+- WSL：自动打开 Windows 上的默认浏览器，WSL2 默认把 Windows 的 `127.0.0.1` 端口转发到 WSL，登录页能直接打开；关掉了端口转发（`.wslconfig` 里 `localhostForwarding=false`）时打不开，要把转发打开
+- SSH 到 Mac / Linux 上执行：按上面「打不开浏览器时」处理
+- refresh_token：Mac 存钥匙串，Linux 桌面存密钥环；Mac 钥匙串锁着（例如 SSH 登录）、Linux 没有密钥环（服务器、WSL、Docker 常见）时退回明文，文件权限 600
+
 ## 服务器上的地址
 
-- `--host` 填前端调接口用的后端地址（nginx 转发后的外网地址，例如 `https://boot.example.com/jeecgboot`），换 token 也走这个地址
-- 后端要把 `jeecg.domainUrl.pc` 配成前端的外网地址，授权页地址是用它拼出来的；默认值是 `http://localhost:3100`，没改时 CLI 会提示
-- 授权后浏览器跳回的是你电脑上的 `127.0.0.1`，服务器不需要访问你的电脑，也不用开端口
+- `--host` 填前端调接口用的后端地址（nginx 转发后的外网地址，例如 `https://boot.example.com/jeecgboot`），登录、换 token 都走这个地址
+- 积木的授权页在积木自己的地址下，CLI 直接用 `--host` 拼，经过反向代理改了路径也没问题
 - 多个环境各登录一次，用 `--host` 切换，最后登录的是默认地址
 
 ## 积木报表的宿主要求
@@ -63,8 +93,11 @@ jeecg auth logout [--host <地址>]                   # 撤销授权并删除本
 
 ## 凭证
 
-存在 `~/.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 天，每次刷新换新的。
+存在 `~/.jeecg/credentials.json`，按地址区分，文件权限 600。refresh_token（30 天有效、能换出新 token）加密保存：Windows 用系统自带的 DPAPI（密文和当前 Windows 账号绑定），macOS 存系统钥匙串（钥匙串锁着时退回明文），Linux 有 `secret-tool` 就存系统密钥环，没有时退回明文并提示；存进去后会读回来比对，存失败不会悄悄丢掉 refresh_token；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）。老版本会提示「没有开启在线授权」。
+- JeecgBoot / 敲敲云：`/.well-known/oauth-authorization-server`、`/oauth2/token`（账号密码登录、refresh_token 续期）、`/oauth2/revoke`、`/oauth2/userinfo`，验证码用原来的 `/sys/randomImage/{key}`；不需要前端页面
+- 积木报表：`/jmreport/` 下的授权配置、授权页、换 token、撤销接口
+
+老版本会提示「没有开启在线授权」（LHZP-2457）。

package/bin/jeecg.js

@@ -1,17 +1,21 @@
 #!/usr/bin/env node
 'use strict';
+// 用到 Node 18 自带的 fetch。Linux 发行版自带的 Node 常常偏旧（例如 Ubuntu 22.04 用 apt 装的是 12），
+// 不先拦住的话会报一串语法错误或 fetch is not defined，看不出原因
+if (Number(process.versions.node.split('.')[0]) < 18) {
+  console.error('jeecg 需要 Node.js 18 及以上，当前是 ' + process.version + '，请升级后再试（可以用 nvm 或从 https://nodejs.org 安装）');
+  process.exit(1);
+}
 const auth = require('../lib/auth');
 
 const USAGE = `jeecg 命令行工具
 
 用法：
-  jeecg auth token [--host <地址>] [--type <产品>] [--scope <权限>] [--no-open] [--manual]
+  jeecg auth token [--host <地址>] [--type <产品>] [--no-open]
       输出可用的 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 地址，把它交给这条命令完成登录
+      快过期自动刷新；没登录过或登录已失效时自动打开浏览器登录，完成后输出（提示信息打到 stderr，不影响取值）
+  jeecg auth login [--host <地址>] [--type <产品>] [--no-open]
+      只登录（最多等 5 分钟），不输出 token；已经登录过时直接确认租户，也可以在页面上切换账号
   jeecg auth status [--host <地址>] [--json]
       查看本机登录状态：地址、产品、用户、租户（不输出 token）
   jeecg auth logout [--host <地址>]
@@ -23,11 +27,18 @@ const USAGE = `jeecg 命令行工具
   jimureport    积木报表，地址填应用地址，例如 http://127.0.0.1:8085（带不带 /jmreport 都行）
   不填时按 jeecgboot、jimureport 的顺序自动探测；敲敲云要明确写 --type qiaoqiaoyun
 
-打不开浏览器时（SSH、没有图形界面的 Linux）：
-  在终端里：把浏览器地址栏的地址粘贴回终端即可
-  被 AI 调用：命令打印授权链接后退出（退出码 2），用户授权后执行 jeecg auth complete "<地址>"；也可以加 --manual 主动这样做`;
+登录页：
+  JeecgBoot / 敲敲云：CLI 在本机打开登录页，输入账号、密码、验证码，确认租户后点「授权」
+  积木报表：打开积木自己的授权页，没登录时先跳到宿主系统的登录页
+
+打不开浏览器时（SSH 登录的服务器）：
+  JeecgBoot / 敲敲云：在自己电脑的浏览器里打开命令打印的登录页地址；VS Code、Cursor 远程会自动转发端口，
+    普通 SSH 先执行 ssh -L <端口>:127.0.0.1:<端口> <用户>@<服务器>；
+    被 AI 调用时 jeecg auth token 直接提示后退出（退出码 2），改为在后台执行 jeecg auth login 等用户登录
+  积木报表：在自己电脑上打开授权链接，授权后把浏览器地址栏的地址粘贴回终端；被 AI 调用时命令打印链接后退出（退出码 2），
+    用户授权后执行 jeecg auth complete "<地址>"；也可以加 --manual 主动这样做`;
 
-const VALUE_OPTIONS = ['host', 'scope', 'type'];
+const VALUE_OPTIONS = ['host', 'type'];
 
 function parseArgs(argv) {
   const args = { _: [] };

package/lib/auth.js

@@ -2,36 +2,42 @@
 /**
  * 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）
+ * 登录方式按产品分两种：
+ * - JeecgBoot / 敲敲云：CLI 在本机 127.0.0.1 起登录页（见 page.js），浏览器里登录、确认租户，
+ *   CLI 用账号密码向后端 /oauth2/token 换 token；不依赖 vue3 前端，也不用配置前端地址
+ * - 积木报表：独立部署的积木没有统一的登录接口（登录由宿主系统负责），走积木自己的授权页（OAuth2 授权码 + PKCE）：
+ *   本机起回调服务 → 打开积木授权页（没登录先跳宿主登录页）→ 点「授权」后浏览器带着授权码跳回 → 用授权码 + code_verifier 换 token
  *
- * 打不开本机浏览器时（SSH、没有图形界面的 Linux）：在终端里可以把浏览器地址栏的地址粘贴回来；
- * 被 AI 调用（不在终端里）时打印链接后退出，用户授权后把地址栏的地址交给 jeecg auth complete
+ * token 存到 ~/.jeecg/credentials.json（refresh_token 加密，见 secret.js），快过期时用 refresh_token 自动续期
  *
  * 输出约定：stdout 只放给程序用的结果（token、status --json），提示信息一律打到 stderr，
  * 这样 --token "$(jeecg auth token)" 里就算触发了登录，拿到的也只有 token
  */
 const crypto = require('crypto');
+const fs = require('fs');
 const http = require('http');
 const readline = require('readline');
 const { spawn } = require('child_process');
 const store = require('./store');
 const secret = require('./secret');
+const { pageLogin } = require('./page');
 
-/** 后端内置的公共客户端，没有 secret，靠 PKCE 防止授权码被截获后冒用 */
+/** 后端内置的公共客户端，没有 secret */
 const CLIENT_ID = 'jeecg-cli';
-/** 手动执行 jeecg auth login 时，等用户点授权最多 5 分钟（和后端授权码有效期一致） */
+/** 手动执行 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 */
+/** 被 AI 调用又打不开浏览器时的退出码：这次没拿到 token，按命令打印的提示让用户在自己电脑上完成登录 */
 const MANUAL_EXIT_CODE = 2;
 const HOST_EXAMPLE = 'JeecgBoot / 敲敲云 http://127.0.0.1:8080/jeecg-boot，积木报表 http://127.0.0.1:8085';
+/** 打不开浏览器时（SSH 登录的服务器），告诉用户怎么在自己电脑上打开本机登录页；{port} 换成登录页的端口 */
+const REMOTE_HINT =
+  '这台机器打不开浏览器（例如 SSH 登录的服务器），请在你自己电脑的浏览器里打开上面的地址：\n' +
+  '- VS Code、Cursor 等远程连接会自动转发端口，直接点开链接即可\n' +
+  '- 普通 SSH：先在自己电脑上执行 ssh -L {port}:127.0.0.1:{port} <用户>@<服务器>，再打开链接';
 
 /**
  * 产品标识（--type），决定请求后端哪组接口：
@@ -49,7 +55,7 @@ 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);
+  const cred = await browserLogin(host, type, args, LOGIN_TIMEOUT_MS, true);
   if (cred) {
     console.error(successText(cred));
   }
@@ -59,7 +65,7 @@ async function login(args) {
  * 输出可用的 access_token（给脚本用：--token "$(jeecg auth token)"），一条命令把取 token 的几种情况都处理掉：
  * 1. 已登录且没过期：直接输出
  * 2. 快过期：用 refresh_token 换新的
- * 3. 没登录过，或者登录已过期 / 被撤销：自动打开浏览器授权，用户点「授权」后输出
+ * 3. 没登录过，或者登录已过期 / 被撤销：自动打开浏览器登录，完成后输出
  */
 async function token(args) {
   const { host, type } = await resolveTarget(args, true);
@@ -73,10 +79,10 @@ async function token(args) {
     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);
+  console.error(cred ? `登录已过期或已被撤销（${host}），重新登录：` : `还没有登录 ${host}，开始登录：`);
+  const fresh = await browserLogin(host, type || (cred && cred.type), args, AUTO_LOGIN_TIMEOUT_MS, false);
   if (!fresh) {
-    // 打不开浏览器：已经打印了授权链接，等 jeecg auth complete，这次不输出 token
+    // 打不开浏览器：已经打印了怎么在用户自己电脑上登录，这次不输出 token
     return;
   }
   console.error(successText(fresh));
@@ -84,7 +90,7 @@ async function token(args) {
 }
 
 /**
- * 用浏览器地址栏里的回调地址完成授权：配合 jeecg auth login --manual，或者打不开浏览器时自动打印的链接
+ * 用浏览器地址栏里的回调地址完成积木的授权：配合 jeecg auth login --manual，或者打不开浏览器时自动打印的链接
  */
 async function complete(args) {
   const callbackUrl = args._[2];
@@ -114,6 +120,7 @@ async function status(args) {
       type: typeOf(data.hosts[h]),
       username: data.hosts[h].username,
       tenant_id: data.hosts[h].tenantId,
+      tenant_name: data.hosts[h].tenantName || null,
       default: h === data.defaultHost,
     }));
   if (args.json) {
@@ -126,7 +133,7 @@ async function status(args) {
     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}` : ''}`);
+    console.log(`${c.default ? '* ' : '  '}${c.host}  ${PRODUCTS[c.type].name}  用户 ${c.username}${tenantText(c.tenant_id, c.tenant_name, '  租户 ')}`);
   }
 }
 
@@ -141,11 +148,7 @@ async function logout(args) {
   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 }),
-      });
+      await revokeToken(cred.revocationEndpoint, refreshToken);
     } catch (e) {
       console.log(`服务器撤销失败（${e.message}），只删除了本机凭证`);
     }
@@ -160,13 +163,16 @@ async function logout(args) {
 }
 
 /**
- * 浏览器授权登录，成功后保存凭证并设为默认地址；打不开浏览器又不在终端里时返回 null（改由 jeecg auth complete 完成）
+ * 浏览器登录，成功后保存凭证并设为默认地址；被 AI 调用又打不开浏览器时返回 null（已打印怎么在用户自己电脑上完成）
+ *
+ * @param explicitLogin 是不是 jeecg auth login：已经登录过时登录页直接显示确认租户（用来换租户）；
+ *                      打不开浏览器时也起登录页等用户。jeecg auth token 自动登录时为 false
  */
-async function browserLogin(host, type, args, timeoutMs) {
+async function browserLogin(host, type, args, timeoutMs, explicitLogin) {
   // 1. 按产品标识请求对应的授权配置；没给标识时按 DETECT_ORDER 依次探测
   let meta = null;
   for (const t of type ? [type] : DETECT_ORDER) {
-    meta = await fetchMetadata(host, PRODUCTS[t].prefix);
+    meta = await fetchMetadata(host, t);
     if (meta) {
       type = t;
       break;
@@ -178,39 +184,117 @@ async function browserLogin(host, type, args, timeoutMs) {
   // 换 token、撤销直接用用户给的地址拼：nginx 常把外网 /jeecgboot 转发到后端 /jeecg-boot，
   // 后端按请求算出来的 token_endpoint（.../jeecg-boot/oauth2/token）在外网访问不到
   const base = host + PRODUCTS[type].prefix;
+  const endpoints = { tokenEndpoint: `${base}/oauth2/token`, revocationEndpoint: `${base}/oauth2/revoke` };
+  return type === 'jimureport' ? oauthLogin(host, type, endpoints, args, timeoutMs) : jeecgLogin(host, type, meta, endpoints, args, timeoutMs, explicitLogin);
+}
+
+/**
+ * JeecgBoot / 敲敲云：本机登录页（page.js），登录、确认租户后保存凭证
+ */
+async function jeecgLogin(host, type, meta, endpoints, args, timeoutMs, explicitLogin) {
+  // 被 AI 调用（不在终端里）又打不开浏览器（例如 SSH 登录的服务器）：AI 的命令执行完才看得到输出，
+  // 登录页地址等到超时也转不到用户手里，直接说明怎么做并退出
+  if (!explicitLogin && !process.stdin.isTTY && !hasLocalBrowser()) {
+    console.error(
+      `这台机器打不开浏览器（例如 SSH 登录的服务器），没法自动登录。请在后台执行：\n  jeecg auth login --host ${host} --type ${type}\n` +
+        '它会打印登录页地址并等待 5 分钟：把地址发给用户，在用户自己电脑的浏览器里打开（VS Code、Cursor 远程会自动转发端口；' +
+        '普通 SSH 先在自己电脑上执行 ssh -L <端口>:127.0.0.1:<端口> <用户>@<服务器>），登录并点「授权」后，再重新执行刚才的命令'
+    );
+    process.exitCode = MANUAL_EXIT_CODE;
+    return null;
+  }
+  const old = store.load().hosts[host];
+  // 已经登录过：用已有的 token 查当前账号，登录页直接显示确认租户（页面上可以点「切换账号」重新登录）
+  const user = explicitLogin && old ? await currentUser(host, old) : null;
+  // 默认选中本机上次选的租户（后端返回的默认租户是网页上次登录的租户）
+  if (user && old.tenantId != null && (user.tenants || []).some((t) => t.id === old.tenantId)) {
+    user.tenant_id = old.tenantId;
+  }
+  const result = await pageLogin({
+    host,
+    productName: PRODUCTS[type].name,
+    captcha: meta.login_captcha !== false,
+    tokenEndpoint: endpoints.tokenEndpoint,
+    revocationEndpoint: endpoints.revocationEndpoint,
+    user,
+    openBrowser: args.open !== false && hasLocalBrowser(),
+    open: openBrowser,
+    remoteHint: hasLocalBrowser() ? '' : REMOTE_HINT,
+    timeoutMs,
+  });
+  const tenants = result.token ? result.token.tenants : user.tenants;
+  const tenant = (tenants || []).find((t) => t.id === result.tenantId);
+  const data = store.load();
+  if (result.token) {
+    // 重新登录了：之前的 refresh_token 用不上了，撤销掉（要在保存新凭证之前取出来，钥匙串里同一个地址只存一份）
+    const oldRefreshToken = old ? secret.unprotect(host, old.refreshToken) : null;
+    data.hosts[host] = toCredential(result.token, host, type, endpoints.tokenEndpoint, endpoints.revocationEndpoint, result.tenantId, tenant && tenant.name);
+    if (oldRefreshToken) {
+      revokeToken(old.revocationEndpoint, oldRefreshToken).catch(() => {});
+    }
+  } else {
+    // 沿用已有的登录，只换了租户
+    data.hosts[host] = { ...old, type, tenantId: result.tenantId, tenantName: tenant ? tenant.name : null };
+  }
+  data.defaultHost = host;
+  store.save(data);
+  return data.hosts[host];
+}
+
+/**
+ * CLI 已有的 token 还能用时，查当前账号和可选租户；过期、被撤销或者后端没有这个接口时返回 null（登录页显示登录表单）
+ */
+async function currentUser(host, cred) {
+  if (Date.now() >= cred.expiresAt) {
+    return null;
+  }
+  try {
+    const res = await fetch(`${host}/oauth2/userinfo`, { headers: { 'X-Access-Token': cred.accessToken } });
+    const body = await res.json().catch(() => ({}));
+    return res.ok && body.success && body.result ? body.result : null;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * 积木报表：积木自己的授权页（授权码 + PKCE）
+ */
+async function oauthLogin(host, type, endpoints, args, timeoutMs) {
   const login = {
     host,
     type,
     verifier: crypto.randomBytes(32).toString('base64url'),
     state: crypto.randomBytes(16).toString('base64url'),
-    tokenEndpoint: `${base}/oauth2/token`,
-    revocationEndpoint: `${base}/oauth2/revoke`,
+    ...endpoints,
+    // 授权页在积木自己的地址下，直接用 --host 拼（反向代理改了路径时，后端按请求算出来的地址外网访问不到）
+    authorizeEndpoint: `${host}${PRODUCTS.jimureport.prefix}/oauth2/authorize`,
   };
-  warnLocalAuthorizePage(meta.authorization_endpoint, host);
 
-  // 2. 打不开本机浏览器又不在终端里（例如 AI 在服务器上调用）：打印链接后退出，等 jeecg auth complete
+  // 打不开本机浏览器又不在终端里（例如 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(`请在自己电脑的浏览器里打开下面的链接，确认授权（${PRODUCTS[type].name}，5 分钟内有效）：\n${authorizeUrl(login)}\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`);
+  console.error(`请在浏览器中确认授权（${PRODUCTS[type].name}）：\n${authorizeUrl(login)}\n`);
   const browserOpened = args.open !== false && hasLocalBrowser();
   if (browserOpened) {
-    openBrowser(authorizeUrl(meta, login, args.scope));
+    openBrowser(authorizeUrl(login));
   }
-  // 在终端里又没自动打开浏览器（--no-open、SSH）：浏览器跳回时可能打不开，也可以把地址栏的地址粘贴回来
-  const paste = !browserOpened && process.stdin.isTTY ? waitForPaste(login.state) : null;
+  // 在终端里又没自动打开浏览器（--no-open、SSH）：浏览器跳回时可能打不开，也可以把地址栏的地址粘贴回来；
+  // WSL 关掉了端口转发（.wslconfig 里 localhostForwarding=false）时，Windows 浏览器跳回的地址也打不开，同样允许粘贴
+  const paste = (!browserOpened || isWsl()) && process.stdin.isTTY ? waitForPaste(login.state) : null;
 
-  // 4. 等用户点「授权」，用授权码换 token
+  // 等用户点「授权」，用授权码换 token
   let code;
   try {
     code = await (paste ? Promise.race([callback.waitForCode(timeoutMs), paste.promise]) : callback.waitForCode(timeoutMs));
@@ -224,7 +308,7 @@ async function browserLogin(host, type, args, timeoutMs) {
 }
 
 /**
- * 用授权码 + code_verifier 换 token，保存凭证并设为默认地址
+ * 积木：用授权码 + code_verifier 换 token，保存凭证并设为默认地址
  */
 async function exchangeCode(login, code) {
   const t = await requestToken(login.tokenEndpoint, {
@@ -235,14 +319,14 @@ async function exchangeCode(login, code) {
     client_id: CLIENT_ID,
   });
   const data = store.load();
-  data.hosts[login.host] = toCredential(t, login.host, login.type, login.tokenEndpoint, login.revocationEndpoint);
+  data.hosts[login.host] = toCredential(t, login.host, login.type, login.tokenEndpoint, login.revocationEndpoint, null, null);
   data.defaultHost = login.host;
   store.save(data);
   return data.hosts[login.host];
 }
 
 /**
- * 用 refresh_token 换新 token；登录已过期、被撤销或 refresh_token 解不开时返回 null（由调用方重新授权）
+ * 用 refresh_token 换新 token；登录已过期、被撤销或 refresh_token 解不开时返回 null（由调用方重新登录）
  */
 async function refresh(host, cred) {
   const refreshToken = secret.unprotect(host, cred.refreshToken);
@@ -252,7 +336,8 @@ async function refresh(host, cred) {
   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);
+    // 租户是登录页上选的，只记在本机，刷新时沿用
+    data.hosts[host] = toCredential(t, host, typeOf(cred), cred.tokenEndpoint, cred.revocationEndpoint, cred.tenantId, cred.tenantName);
     store.save(data);
     return data.hosts[host];
   } catch (e) {
@@ -305,21 +390,26 @@ function normalizeHost(host) {
 }
 
 /**
- * 读授权配置；连不上直接报错，接口不存在（老版本、不是这个产品、宿主没开启）返回 null
+ * 读授权配置；连不上直接报错，接口不存在（老版本、不是这个产品、宿主没开启）返回 null。
+ * 积木要有授权页（authorization_endpoint），JeecgBoot / 敲敲云要支持账号密码登录（grant_types_supported 里有 password）
  */
-async function fetchMetadata(host, prefix) {
+async function fetchMetadata(host, type) {
   let res;
   try {
-    res = await fetch(`${host}${prefix}/.well-known/oauth-authorization-server`);
+    res = await fetch(`${host}${PRODUCTS[type].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;
+  if (!res.ok || !meta.token_endpoint) {
+    return null;
+  }
+  const supported = type === 'jimureport' ? Boolean(meta.authorization_endpoint) : (meta.grant_types_supported || []).includes('password');
+  return supported ? meta : null;
 }
 
-function authorizeUrl(meta, login, scope) {
+function authorizeUrl(login) {
   const params = new URLSearchParams({
     response_type: 'code',
     client_id: CLIENT_ID,
@@ -328,10 +418,7 @@ function authorizeUrl(meta, login, scope) {
     code_challenge_method: 'S256',
     state: login.state,
   });
-  if (scope) {
-    params.set('scope', scope);
-  }
-  return `${meta.authorization_endpoint}?${params}`;
+  return `${login.authorizeEndpoint}?${params}`;
 }
 
 /**
@@ -386,9 +473,31 @@ function hasLocalBrowser() {
   if (process.env.SSH_CONNECTION || process.env.SSH_TTY) {
     return false;
   }
+  // WSL 里一般没有图形界面，但可以打开 Windows 上的浏览器
+  if (isWsl()) {
+    return true;
+  }
   return !(process.platform === 'linux' && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY);
 }
 
+/**
+ * 是否在 WSL（Windows 里的 Linux）里：Windows 上用 Claude Code 的人常在 WSL 里跑。
+ * 浏览器在 Windows 那边，WSL2 默认把 Windows 的 127.0.0.1 端口转发到 WSL，浏览器打开本机地址时 CLI 能收到
+ */
+function isWsl() {
+  if (process.platform !== 'linux') {
+    return false;
+  }
+  if (process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP) {
+    return true;
+  }
+  try {
+    return /microsoft/i.test(fs.readFileSync('/proc/version', 'utf8'));
+  } catch (e) {
+    return false;
+  }
+}
+
 function freePort() {
   return new Promise((resolve, reject) => {
     const server = http.createServer();
@@ -408,7 +517,15 @@ function notEnabledText(host, type) {
 }
 
 function successText(cred) {
-  return `登录成功（${PRODUCTS[typeOf(cred)].name}）：${cred.username}${cred.tenantId != null ? `，租户 ${cred.tenantId}` : ''}`;
+  return `登录成功（${PRODUCTS[typeOf(cred)].name}）：${cred.username}${tenantText(cred.tenantId, cred.tenantName, '，租户 ')}`;
+}
+
+/** 租户显示成「十二只绵羊（1014）」，以前存的只有 id */
+function tenantText(id, name, prefix) {
+  if (id == null) {
+    return '';
+  }
+  return prefix + (name ? `${name}（${id}）` : id);
 }
 
 /** 以前存的凭证没有 type，都是 JeecgBoot 地址 */
@@ -416,18 +533,6 @@ 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',
@@ -444,12 +549,21 @@ async function requestToken(endpoint, form) {
   return body;
 }
 
-function toCredential(t, host, type, tokenEndpoint, revocationEndpoint) {
+async function revokeToken(endpoint, refreshToken) {
+  await fetch(endpoint, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    body: new URLSearchParams({ token: refreshToken, client_id: CLIENT_ID }),
+  });
+}
+
+function toCredential(t, host, type, tokenEndpoint, revocationEndpoint, tenantId, tenantName) {
   return {
     type,
     username: t.username,
-    tenantId: t.tenant_id == null ? null : t.tenant_id,
-    scope: t.scope || null,
+    // 登录页上选的租户：JeecgBoot / 敲敲云的租户由请求头 X-Tenant-Id 决定，不绑在 token 上，只记在本机给 skill 用
+    tenantId: tenantId == null ? null : tenantId,
+    tenantName: tenantName || null,
     accessToken: t.access_token,
     refreshToken: secret.protect(host, t.refresh_token),
     expiresAt: Date.now() + Number(t.expires_in || 0) * 1000,
@@ -459,7 +573,7 @@ function toCredential(t, host, type, tokenEndpoint, revocationEndpoint) {
 }
 
 /**
- * 本机回调服务：只监听 127.0.0.1，state 对不上的请求直接忽略（不是这次登录发起的）
+ * 积木的本机回调服务：只监听 127.0.0.1，state 对不上的请求直接忽略（不是这次登录发起的）
  */
 function startCallbackServer(expectedState) {
   let settle;
@@ -519,17 +633,24 @@ function sendPage(res, title, message) {
 }
 
 function openBrowser(url) {
-  // Windows 不走 cmd /c start：URL 里的 & 会被 cmd 当成命令分隔符截断
+  // Windows 不走 cmd /c start：URL 里的 & 会被 cmd 当成命令分隔符截断；WSL 里调 Windows 的 rundll32.exe，打开 Windows 上的默认浏览器
   const [cmd, cmdArgs] =
     process.platform === 'win32'
       ? ['rundll32', ['url.dll,FileProtocolHandler', url]]
+      : isWsl()
+      ? ['rundll32.exe', ['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 });
+    // 命令不存在（例如精简的 Linux 没装 xdg-utils）会触发 error
     child.on('error', tip);
+    // open / xdg-open 找不到能打开链接的浏览器时不触发 error，只是退出码不为 0（xdg-open 是 3 或 4）
+    if (cmd === 'open' || cmd === 'xdg-open') {
+      child.on('exit', (code) => code && tip());
+    }
     child.unref();
   } catch (e) {
     tip();

package/lib/page.js

@@ -0,0 +1,459 @@
+'use strict';
+/**
+ * JeecgBoot / 敲敲云的登录页：CLI 在本机 127.0.0.1 起一个页面，浏览器里登录、确认租户后拿到 token。
+ * 不依赖 vue3 前端，也不用配置前端地址；积木报表还是用积木自己的授权页（见 auth.js 的 oauthLogin）。
+ *
+ * 页面只和本机这个服务通信，由 CLI 转给后端：
+ * - 验证码图片：原来的 /sys/randomImage/{key}
+ * - 登录：/oauth2/token（grant_type=password），返回 token 和可选租户
+ * - CLI 已经登录过（再次执行 jeecg auth login）：/oauth2/userinfo 取当前账号，直接显示确认租户，可以点「切换账号」重新登录
+ *
+ * 防止别的网页操作这个本机服务：地址里带随机串，猜不到；提交只接受同源的 JSON 请求
+ */
+const crypto = require('crypto');
+const http = require('http');
+
+const CLIENT_ID = 'jeecg-cli';
+/** 请求体上限，登录表单用不了这么多 */
+const MAX_BODY = 16 * 1024;
+
+/**
+ * 起登录页，等用户在浏览器里登录并确认租户
+ *
+ * @param {object} opts
+ * @param {string} opts.host 后端地址，例如 http://127.0.0.1:8080/jeecg-boot
+ * @param {string} opts.productName 产品名，显示在页面上，例如 JeecgBoot、敲敲云
+ * @param {boolean} opts.captcha 登录要不要验证码（后端授权配置里的 login_captcha）
+ * @param {string} opts.tokenEndpoint 换 token 的地址
+ * @param {string} opts.revocationEndpoint 撤销授权的地址
+ * @param {object|null} opts.user CLI 已登录时的当前账号（username、realname、tenant_id、tenants），没有时为 null
+ * @param {boolean} opts.openBrowser 是否自动打开浏览器
+ * @param {function} opts.open 打开浏览器的方法
+ * @param {string} opts.remoteHint 打不开浏览器时额外打印的提示（端口转发说明），没有时为空
+ * @param {number} opts.timeoutMs 最多等多久
+ * @returns {Promise<{token: object|null, tenantId: number|null}>} token 为 null 表示沿用已有的登录，只换了租户
+ */
+async function pageLogin(opts) {
+  const secret = crypto.randomBytes(16).toString('base64url');
+  const nonce = crypto.randomBytes(16).toString('base64');
+  // 登录成功、还没点「授权」的 token：点「取消」、超时或换账号重新登录时要撤销
+  let pending = null;
+  let settle;
+  const result = new Promise((resolve, reject) => {
+    settle = { resolve, reject };
+  });
+  result.catch(() => {});
+
+  const server = http.createServer((req, res) => {
+    handle(req, res).catch((e) => {
+      // 请求体太大时连接已经断开，回不了
+      if (!res.headersSent && !res.destroyed) {
+        sendJson(res, 500, { error: e.message });
+      }
+    });
+  });
+
+  async function handle(req, res) {
+    const url = new URL(req.url, 'http://127.0.0.1');
+    const base = `/${secret}`;
+    if (url.pathname !== base && !url.pathname.startsWith(base + '/')) {
+      res.writeHead(404, { Connection: 'close' });
+      res.end();
+      return;
+    }
+    const path = url.pathname.slice(base.length) || '/';
+    if (req.method === 'GET' && path === '/') {
+      sendHtml(res, renderPage(nonce), nonce);
+      return;
+    }
+    if (req.method === 'GET' && path === '/api/init') {
+      sendJson(res, 200, { product: opts.productName, host: opts.host, captcha: opts.captcha, user: opts.user ? pickUser(opts.user) : null });
+      return;
+    }
+    if (req.method === 'GET' && path === '/api/captcha') {
+      sendJson(res, 200, await fetchCaptcha(opts.host, url.searchParams.get('key')));
+      return;
+    }
+    if (req.method !== 'POST' || !isSameOrigin(req)) {
+      sendJson(res, 403, { error: '请求不合法' });
+      return;
+    }
+    const body = await readJson(req);
+    if (path === '/api/login') {
+      const t = await passwordLogin(opts, body);
+      if (t.error) {
+        sendJson(res, 200, { error: t.error });
+        return;
+      }
+      // 在页面上换了账号重新登录：前一个账号的 token 用不上了，撤销掉
+      if (pending) {
+        revoke(opts.revocationEndpoint, pending.refresh_token);
+      }
+      pending = t;
+      sendJson(res, 200, pickUser(t));
+      return;
+    }
+    if (path === '/api/confirm') {
+      const user = pending ? pickUser(pending) : opts.user ? pickUser(opts.user) : null;
+      if (!user) {
+        sendJson(res, 200, { error: '请先登录' });
+        return;
+      }
+      // 只认列表里的租户，页面传来的值对不上就不设
+      const tenant = user.tenants.find((t) => String(t.id) === String(body.tenantId));
+      sendJson(res, 200, { ok: true });
+      settle.resolve({ token: pending, tenantId: tenant ? tenant.id : null });
+      return;
+    }
+    if (path === '/api/cancel') {
+      if (pending) {
+        await revoke(opts.revocationEndpoint, pending.refresh_token);
+        pending = null;
+      }
+      sendJson(res, 200, { ok: true });
+      settle.reject(new Error('已在浏览器中取消授权'));
+      return;
+    }
+    sendJson(res, 404, { error: '不支持的请求' });
+  }
+
+  await new Promise((resolve, reject) => {
+    server.on('error', reject);
+    server.listen(0, '127.0.0.1', resolve);
+  });
+  const pageUrl = `http://127.0.0.1:${server.address().port}/${secret}`;
+  console.error(`请在浏览器中登录（${opts.productName}）：\n${pageUrl}\n`);
+  if (opts.remoteHint) {
+    console.error(opts.remoteHint.replace(/\{port\}/g, server.address().port) + '\n');
+  }
+  if (opts.openBrowser) {
+    opts.open(pageUrl);
+  }
+
+  const timer = setTimeout(() => settle.reject(new Error(`等待登录超时（${Math.round(opts.timeoutMs / 1000)} 秒），请重新执行`)), opts.timeoutMs);
+  try {
+    return await result;
+  } catch (e) {
+    // 登录了但没点「授权」就超时：这个 token 不会被保存，撤销掉
+    if (pending) {
+      await revoke(opts.revocationEndpoint, pending.refresh_token);
+    }
+    throw e;
+  } finally {
+    clearTimeout(timer);
+    server.close();
+    // 浏览器会保持长连接，不断开的话进程要等几秒才退出
+    if (server.closeAllConnections) {
+      server.closeAllConnections();
+    }
+  }
+}
+
+/**
+ * 账号密码换 token；失败时返回 { error: 给用户看的原因 }
+ */
+async function passwordLogin(opts, body) {
+  const username = String(body.username || '').trim();
+  const password = String(body.password || '');
+  if (!username || !password) {
+    return { error: '请输入账号和密码' };
+  }
+  const form = { grant_type: 'password', username, password, client_id: CLIENT_ID };
+  if (opts.captcha) {
+    form.captcha = String(body.captcha || '').trim();
+    form.check_key = String(body.checkKey || '');
+  }
+  let res;
+  try {
+    res = await fetch(opts.tokenEndpoint, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: new URLSearchParams(form),
+    });
+  } catch (e) {
+    return { error: `连不上 ${opts.host}：${(e.cause && e.cause.code) || e.message}` };
+  }
+  const t = await res.json().catch(() => ({}));
+  if (!res.ok || !t.access_token) {
+    return { error: t.error_description || t.message || `登录失败（HTTP ${res.status}）` };
+  }
+  return t;
+}
+
+/**
+ * 取验证码图片：原来的 /sys/randomImage/{key}，返回 data:image/...;base64 开头的图片
+ */
+async function fetchCaptcha(host, key) {
+  if (!/^[A-Za-z0-9]{1,64}$/.test(key || '')) {
+    return { error: '验证码参数不对' };
+  }
+  try {
+    const res = await fetch(`${host}/sys/randomImage/${key}`);
+    const body = await res.json().catch(() => ({}));
+    const image = body.result;
+    return typeof image === 'string' && image.startsWith('data:image/') ? { image } : { error: body.message || '获取验证码失败' };
+  } catch (e) {
+    return { error: `连不上 ${host}` };
+  }
+}
+
+/**
+ * 撤销 refresh_token（对应的 access_token 一起作废），失败不影响主流程
+ */
+async function revoke(endpoint, refreshToken) {
+  try {
+    await fetch(endpoint, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: new URLSearchParams({ token: refreshToken, client_id: CLIENT_ID }),
+    });
+  } catch (e) {
+    // 撤销不了就让它自然过期
+  }
+}
+
+/** 页面只需要账号和租户，不把 token 交给页面 */
+function pickUser(u) {
+  return { username: u.username, realname: u.realname || u.username, tenantId: u.tenant_id == null ? null : u.tenant_id, tenants: Array.isArray(u.tenants) ? u.tenants : [] };
+}
+
+/**
+ * 只接受页面自己发的请求：别的网站跨域提交时 Origin 是它自己的域名。
+ * 不限定 Host：VS Code 远程等端口转发后，浏览器里的地址可能换了端口或域名
+ */
+function isSameOrigin(req) {
+  if (!String(req.headers['content-type'] || '').startsWith('application/json')) {
+    return false;
+  }
+  const origin = req.headers.origin;
+  return !origin || origin === `http://${req.headers.host}` || origin === `https://${req.headers.host}`;
+}
+
+function readJson(req) {
+  return new Promise((resolve, reject) => {
+    let size = 0;
+    const chunks = [];
+    req.on('data', (c) => {
+      size += c.length;
+      if (size > MAX_BODY) {
+        reject(new Error('请求太大'));
+        req.destroy();
+        return;
+      }
+      chunks.push(c);
+    });
+    req.on('end', () => {
+      try {
+        resolve(JSON.parse(Buffer.concat(chunks).toString('utf8') || '{}'));
+      } catch (e) {
+        resolve({});
+      }
+    });
+    req.on('error', reject);
+  });
+}
+
+function sendJson(res, status, data) {
+  res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8', 'Cache-Control': 'no-store', Connection: 'close' });
+  res.end(JSON.stringify(data));
+}
+
+function sendHtml(res, html, nonce) {
+  res.writeHead(200, {
+    'Content-Type': 'text/html; charset=utf-8',
+    'Cache-Control': 'no-store',
+    'X-Frame-Options': 'DENY',
+    'Referrer-Policy': 'no-referrer',
+    // 页面脚本只允许带 nonce 的那一段；不能被嵌进别的网页（防止诱导点「授权」）
+    'Content-Security-Policy': `default-src 'none'; script-src 'nonce-${nonce}'; style-src 'unsafe-inline'; img-src data:; connect-src 'self'; form-action 'none'; frame-ancestors 'none'; base-uri 'none'`,
+    Connection: 'close',
+  });
+  res.end(html);
+}
+
+/**
+ * 登录页：登录 → 确认租户 → 结果，三步在同一个页面里切换
+ */
+function renderPage(nonce) {
+  return `<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>登录 - jeecg CLI</title>
+<style>
+  * { box-sizing: border-box; }
+  body { margin: 0; min-height: 100vh; display: flex; align-items: center; justify-content: center; background: #f2f4f7;
+    font: 14px/1.5 -apple-system, BlinkMacSystemFont, "Segoe UI", "PingFang SC", "Microsoft YaHei", sans-serif; color: #1f2329; }
+  .card { width: 420px; max-width: calc(100vw - 32px); background: #fff; border-radius: 12px; box-shadow: 0 8px 32px rgba(31, 35, 41, .08); padding: 32px 36px 28px; }
+  .brand { display: flex; align-items: center; gap: 12px; padding-bottom: 20px; margin-bottom: 24px; border-bottom: 1px solid #eef0f3; }
+  .logo { width: 40px; height: 40px; border-radius: 10px; background: linear-gradient(135deg, #3b82f6, #1d4ed8); color: #fff;
+    display: flex; align-items: center; justify-content: center; font-size: 18px; font-weight: 700; flex-shrink: 0; }
+  .brand-name { font-size: 16px; font-weight: 600; }
+  .muted { font-size: 12px; color: #8f959e; word-break: break-all; }
+  h1 { font-size: 20px; margin: 0 0 6px; }
+  .sub { color: #646a73; margin: 0 0 22px; }
+  .field { display: block; margin-bottom: 16px; }
+  .field > span { display: block; margin-bottom: 6px; color: #646a73; font-size: 13px; }
+  input, select { width: 100%; height: 40px; padding: 0 12px; border: 1px solid #d5d8dc; border-radius: 8px; font-size: 14px; outline: none; background: #fff; color: inherit; }
+  input:focus, select:focus { border-color: #3b82f6; box-shadow: 0 0 0 3px rgba(59, 130, 246, .15); }
+  .captcha { display: flex; gap: 10px; }
+  .captcha img { height: 40px; width: 120px; border: 1px solid #d5d8dc; border-radius: 8px; cursor: pointer; flex-shrink: 0; }
+  .btn { width: 100%; height: 42px; border: 0; border-radius: 8px; background: #2563eb; color: #fff; font-size: 15px; cursor: pointer; }
+  .btn:hover { background: #1d4ed8; }
+  .btn:disabled { opacity: .6; cursor: default; }
+  .btn.ghost { background: #fff; color: #1f2329; border: 1px solid #d5d8dc; }
+  .btn.ghost:hover { background: #f5f6f7; }
+  .actions { display: flex; gap: 12px; margin-top: 24px; }
+  .error { color: #e5484d; min-height: 20px; margin: -4px 0 12px; font-size: 13px; }
+  .account { display: flex; align-items: center; gap: 12px; padding: 12px 14px; background: #f7f8fa; border-radius: 10px; margin-bottom: 18px; }
+  .avatar { width: 40px; height: 40px; border-radius: 50%; background: #dbeafe; color: #1d4ed8; display: flex; align-items: center; justify-content: center; font-weight: 600; flex-shrink: 0; }
+  .account-name { font-weight: 600; }
+  .switch { margin-left: auto; color: #2563eb; cursor: pointer; font-size: 13px; background: none; border: 0; padding: 0; }
+  .perm { margin: 0; padding: 0; list-style: none; color: #646a73; }
+  .perm li { position: relative; padding-left: 20px; margin-bottom: 6px; }
+  .perm li::before { content: ""; position: absolute; left: 4px; top: 8px; width: 6px; height: 6px; border-radius: 50%; background: #3b82f6; }
+  .result { text-align: center; padding: 8px 0 4px; }
+  .result-icon { width: 56px; height: 56px; margin: 0 auto 14px; border-radius: 50%; display: flex; align-items: center; justify-content: center; font-size: 28px; color: #fff; background: #22c55e; }
+  .result-icon.cancel { background: #9ca3af; }
+  .hidden { display: none !important; }
+</style>
+</head>
+<body>
+<div class="card">
+  <div class="brand">
+    <div class="logo">J</div>
+    <div><div class="brand-name" id="product"></div><div class="muted" id="host"></div></div>
+  </div>
+
+  <form id="login" class="hidden" autocomplete="on">
+    <h1>登录</h1>
+    <p class="sub">登录后授权 jeecg CLI 以你的身份调用接口</p>
+    <label class="field"><span>账号</span><input name="username" autocomplete="username" required></label>
+    <label class="field"><span>密码</span><input name="password" type="password" autocomplete="current-password" required></label>
+    <div class="field hidden" id="captchaRow">
+      <span>验证码</span>
+      <div class="captcha"><input name="captcha" autocomplete="off" maxlength="8"><img id="captchaImg" alt="验证码" title="看不清？点击换一张"></div>
+    </div>
+    <div class="error" id="loginError"></div>
+    <button class="btn" type="submit">登录</button>
+  </form>
+
+  <div id="confirm" class="hidden">
+    <h1>授权 jeecg CLI</h1>
+    <p class="sub">jeecg CLI 申请以你的身份访问 <span id="product2"></span></p>
+    <div class="account">
+      <div class="avatar" id="avatar"></div>
+      <div><div class="account-name" id="realname"></div><div class="muted" id="username"></div></div>
+      <button class="switch" id="switch" type="button">切换账号</button>
+    </div>
+    <label class="field" id="tenantRow"><span>租户</span><select id="tenant"></select></label>
+    <ul class="perm">
+      <li>以你的身份调用接口，供 AI Skills 使用</li>
+      <li>实际权限不会超过你在系统中的权限</li>
+    </ul>
+    <div class="error" id="confirmError"></div>
+    <div class="actions">
+      <button class="btn ghost" id="cancel" type="button">取消</button>
+      <button class="btn" id="approve" type="button">授权</button>
+    </div>
+  </div>
+
+  <div id="done" class="hidden result">
+    <div class="result-icon" id="doneIcon">✓</div>
+    <h1 id="doneTitle"></h1>
+    <p class="sub" id="doneText"></p>
+  </div>
+</div>
+<script nonce="${nonce}">
+  var base = location.pathname.replace(/\\/$/, '');
+  var state = null;
+  var checkKey = '';
+  function $(id) { return document.getElementById(id); }
+  function show(id) { ['login', 'confirm', 'done'].forEach(function (v) { $(v).classList.toggle('hidden', v !== id); }); }
+  function api(path, body) {
+    var init = body === undefined ? {} : { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) };
+    return fetch(base + '/api/' + path, init).then(function (r) { return r.json(); });
+  }
+  function lost() { showDone(false, '连接已断开', 'jeecg CLI 已经退出，请回到终端重新执行登录命令。'); }
+  function showDone(ok, title, text) {
+    $('doneIcon').textContent = ok ? '✓' : '×';
+    $('doneIcon').classList.toggle('cancel', !ok);
+    $('doneTitle').textContent = title;
+    $('doneText').textContent = text;
+    show('done');
+  }
+  function refreshCaptcha() {
+    if (!state.captcha) { return; }
+    checkKey = Date.now() + '' + Math.floor(Math.random() * 1000);
+    api('captcha?key=' + checkKey).then(function (r) {
+      if (r.image) { $('captchaImg').src = r.image; } else { $('loginError').textContent = r.error || '获取验证码失败'; }
+    }).catch(lost);
+  }
+  function showLogin() {
+    show('login');
+    $('loginError').textContent = '';
+    refreshCaptcha();
+    document.forms.login.username.focus();
+  }
+  function showConfirm(user) {
+    $('realname').textContent = user.realname;
+    $('username').textContent = user.username;
+    $('avatar').textContent = (user.realname || '?').slice(0, 1);
+    var select = $('tenant');
+    select.innerHTML = '';
+    user.tenants.forEach(function (t) {
+      var option = document.createElement('option');
+      option.value = t.id;
+      option.textContent = t.name;
+      option.selected = String(t.id) === String(user.tenantId);
+      select.appendChild(option);
+    });
+    $('tenantRow').classList.toggle('hidden', user.tenants.length === 0);
+    $('confirmError').textContent = '';
+    show('confirm');
+  }
+  document.forms.login.addEventListener('submit', function (e) {
+    e.preventDefault();
+    var form = e.target;
+    var button = form.querySelector('button');
+    button.disabled = true;
+    $('loginError').textContent = '';
+    api('login', { username: form.username.value, password: form.password.value, captcha: form.captcha.value, checkKey: checkKey }).then(function (r) {
+      if (r.error) {
+        $('loginError').textContent = r.error;
+        form.captcha.value = '';
+        refreshCaptcha();
+        return;
+      }
+      form.password.value = '';
+      form.captcha.value = '';
+      showConfirm(r);
+    }).catch(lost).then(function () { button.disabled = false; });
+  });
+  $('captchaImg').addEventListener('click', refreshCaptcha);
+  $('switch').addEventListener('click', showLogin);
+  $('approve').addEventListener('click', function () {
+    $('approve').disabled = true;
+    api('confirm', { tenantId: $('tenant').value }).then(function (r) {
+      if (r.error) { $('confirmError').textContent = r.error; return; }
+      showDone(true, '授权成功', '可以关闭此页面，回到终端继续使用。');
+    }).catch(lost).then(function () { $('approve').disabled = false; });
+  });
+  $('cancel').addEventListener('click', function () {
+    api('cancel', {}).then(function () { showDone(false, '已取消授权', '可以关闭此页面。'); }).catch(lost);
+  });
+  api('init').then(function (r) {
+    state = r;
+    $('product').textContent = r.product;
+    $('product2').textContent = r.product;
+    $('host').textContent = r.host;
+    $('captchaRow').classList.toggle('hidden', !r.captcha);
+    if (r.user) { showConfirm(r.user); } else { showLogin(); }
+  }).catch(lost);
+</script>
+</body>
+</html>`;
+}
+
+module.exports = { pageLogin };

package/lib/secret.js

@@ -4,14 +4,17 @@
  * access_token 有效期短，而且每次 jeecg auth token 都要读，保持原样，取 token 不变慢。
  *
  * - Windows：DPAPI，系统自带，密文和当前 Windows 账号绑定（拷到别的电脑或账号解不开）；通过 PowerShell 调用，一次约 0.35 秒
- * - macOS：系统钥匙串（security 命令）
+ * - macOS：系统钥匙串（security 命令）；钥匙串锁着时（例如 SSH 登录）退回明文
  * - Linux：有 secret-tool 就存进系统密钥环；没有（服务器上常见）或调用失败，就退回明文（文件权限 600）并提示
+ * - WSL、Docker 容器等其它 Linux 环境同上，一般没有密钥环，走明文
  *
  * credentials.json 里存的值带前缀说明存在哪：dpapi:<密文> / keychain: / secret-tool: ；没有前缀的是明文（以前存的或退回明文的）
  */
 const { execFileSync } = require('child_process');
 
 const SERVICE = 'jeecg-cli';
+// 调系统命令最多等 30 秒：Linux 密钥环被锁时会弹窗等用户输密码，等不到就退回明文，不让命令一直卡着
+const TIMEOUT_MS = 30 * 1000;
 // 明文和密文都从环境变量传给 PowerShell，不出现在进程命令行里
 const PROTECT_PS =
   "Add-Type -AssemblyName System.Security;[Convert]::ToBase64String([Security.Cryptography.ProtectedData]::Protect([Text.Encoding]::UTF8.GetBytes($env:JEECG_SECRET),$null,'CurrentUser'))";
@@ -26,13 +29,19 @@ function protect(host, secret) {
     if (process.platform === 'win32') {
       return 'dpapi:' + powershell(PROTECT_PS, secret);
     }
+    // 存完读回来比对一次：security -i 里的命令失败时退出码也可能是 0（例如 SSH 登录的 Mac 钥匙串是锁着的），
+    // 不比对的话会以为存进去了，之后读不出来，每次 token 过期都要重新授权
+    const stored = process.platform === 'darwin' ? 'keychain:' : 'secret-tool:';
     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('security', ['-i'], { input: `add-generic-password -U -a "${host}" -s "${SERVICE}" -w "${secret}"\n`, stdio: ['pipe', 'ignore', 'pipe'], timeout: TIMEOUT_MS });
+    } else {
+      execFileSync('secret-tool', ['store', `--label=jeecg CLI ${host}`, 'service', SERVICE, 'account', host], { input: secret, stdio: ['pipe', 'ignore', 'pipe'], timeout: TIMEOUT_MS });
     }
-    execFileSync('secret-tool', ['store', `--label=jeecg CLI ${host}`, 'service', SERVICE, 'account', host], { input: secret, stdio: ['pipe', 'ignore', 'pipe'] });
-    return 'secret-tool:';
+    if (unprotect(host, stored) !== secret) {
+      throw new Error('写入后读不出来');
+    }
+    return stored;
   } catch (e) {
     console.error(`提示：本机没有可用的系统密钥存储（${e.code || e.message}），refresh_token 以明文保存在 ~/.jeecg/credentials.json（文件权限 600）`);
     return secret;
@@ -51,10 +60,10 @@ function unprotect(host, stored) {
       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();
+      return execFileSync('security', ['find-generic-password', '-a', host, '-s', SERVICE, '-w'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: TIMEOUT_MS }).trim();
     }
     if (stored === 'secret-tool:') {
-      return execFileSync('secret-tool', ['lookup', 'service', SERVICE, 'account', host], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+      return execFileSync('secret-tool', ['lookup', 'service', SERVICE, 'account', host], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: TIMEOUT_MS }).trim();
     }
   } catch (e) {
     return null;
@@ -68,9 +77,9 @@ function unprotect(host, stored) {
 function remove(host, stored) {
   try {
     if (stored === 'keychain:') {
-      execFileSync('security', ['delete-generic-password', '-a', host, '-s', SERVICE], { stdio: 'ignore' });
+      execFileSync('security', ['delete-generic-password', '-a', host, '-s', SERVICE], { stdio: 'ignore', timeout: TIMEOUT_MS });
     } else if (stored === 'secret-tool:') {
-      execFileSync('secret-tool', ['clear', 'service', SERVICE, 'account', host], { stdio: 'ignore' });
+      execFileSync('secret-tool', ['clear', 'service', SERVICE, 'account', host], { stdio: 'ignore', timeout: TIMEOUT_MS });
     }
   } catch (e) {
     // 本来就没有，不用处理
@@ -83,6 +92,7 @@ function powershell(script, input) {
     encoding: 'utf8',
     windowsHide: true,
     stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: TIMEOUT_MS,
   }).trim();
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ws1298191366/cli",
-  "version": "0.1.1",
-  "description": "JEECG 命令行工具：在浏览器里授权登录 JeecgBoot / 敲敲云，给 AI skills 提供 token",
+  "version": "0.1.3",
+  "description": "JEECG 命令行工具：在浏览器里授权登录 JeecgBoot / 敲敲云 / 积木报表，给 AI skills 提供 token",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public"