@ws1298191366/cli 0.1.0 → 0.1.2

package/README.md

@@ -39,16 +39,32 @@ token 由 shell 在执行时代入，不会出现在命令和对话记录里。
 
 ```bash
 jeecg auth login [--host <地址>] [--type <产品>]   # 只登录（最多等 5 分钟），不输出 token
+jeecg auth complete "<浏览器地址栏里的地址>"          # 打不开浏览器时完成登录
 jeecg auth status --json                            # 本机登录状态：地址、产品、用户、租户（不输出 token）
 jeecg auth logout [--host <地址>]                   # 撤销授权并删除本机凭证
 ```
 
-没有浏览器的环境加 `--no-open`，把打印的链接复制到浏览器打开，同样要点「授权」。
+## 打不开浏览器时（SSH、没有图形界面的 Linux）
+
+- 在终端里：命令会打印授权链接，在自己电脑的浏览器里打开并点「授权」；浏览器跳回的 `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)` 不受影响。
 
 ## 服务器上的地址
 
 - `--host` 填前端调接口用的后端地址（nginx 转发后的外网地址，例如 `https://boot.example.com/jeecgboot`），换 token 也走这个地址
-- 后端要把 `jeecg.domainUrl.pc` 配成前端的外网地址，授权页地址是用它拼出来的；默认值是 `http://localhost:3100`，没改时 CLI 会提示
+- JeecgBoot / 敲敲云的授权页在前端，地址来自后端配置 `jeecg.domainUrl.pc`，最好配成前端的外网地址。它还是默认的 `http://localhost:3100` 而 `--host` 是服务器时，浏览器会打开你自己电脑上的 localhost；CLI 会去 `--host` 同一个域名下找前端（前端根目录的 `_app.config.js` 里记的后端地址和 `--host` 对得上才算），找到就改用它；前端和后端不在同一个域名时，用 `--web <前端地址>` 指定，例如 `--web https://boot.example.com`，指定过会记住
+- 积木的授权页在积木自己的地址下，CLI 直接用 `--host` 拼，经过反向代理改了路径也没问题
 - 授权后浏览器跳回的是你电脑上的 `127.0.0.1`，服务器不需要访问你的电脑，也不用开端口
 - 多个环境各登录一次，用 `--host` 切换，最后登录的是默认地址
 
@@ -58,7 +74,7 @@ jeecg auth logout [--host <地址>]                   # 撤销授权并删除本
 
 ## 凭证
 
-存在 `~/.jeecg/credentials.json`，按地址区分，文件权限 600。JeecgBoot / 敲敲云的 access_token 有效期和网页登录一样（84 小时），积木 2 小时；refresh_token 30 天，每次刷新换新的。
+存在 `~/.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 天，每次刷新换新的。
 
 ## 后端要求
 

package/bin/jeecg.js

@@ -5,11 +5,13 @@ const auth = require('../lib/auth');
 const USAGE = `jeecg 命令行工具
 
 用法：
-  jeecg auth token [--host <地址>] [--type <产品>] [--scope <权限>] [--no-open]
+  jeecg auth token [--host <地址>] [--type <产品>] [--web <前端地址>] [--scope <权限>] [--no-open] [--manual]
       输出可用的 access_token，给脚本用：--token "$(jeecg auth token)"
       快过期自动刷新；没登录过或登录已失效时自动打开浏览器授权，点「授权」后输出（提示信息打到 stderr，不影响取值）
-  jeecg auth login [--host <地址>] [--type <产品>] [--scope <权限>] [--no-open]
-      只登录（最多等 5 分钟），不输出 token；没有浏览器的环境加 --no-open，自己复制链接打开
+  jeecg auth login [--host <地址>] [--type <产品>] [--web <前端地址>] [--scope <权限>] [--no-open] [--manual]
+      只登录（最多等 5 分钟），不输出 token
+  jeecg auth complete "<浏览器地址栏里的地址>"
+      打不开浏览器时用：授权后浏览器会跳到一个打不开的 127.0.0.1 地址，把它交给这条命令完成登录
   jeecg auth status [--host <地址>] [--json]
       查看本机登录状态：地址、产品、用户、租户（不输出 token）
   jeecg auth logout [--host <地址>]
@@ -19,9 +21,17 @@ const USAGE = `jeecg 命令行工具
   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`;
+  不填时按 jeecgboot、jimureport 的顺序自动探测；敲敲云要明确写 --type qiaoqiaoyun
 
-const VALUE_OPTIONS = ['host', 'scope', 'type'];
+--web 前端地址（JeecgBoot / 敲敲云的授权页在前端）：
+  默认用后端配置 jeecg.domainUrl.pc；它还是 localhost 而 --host 是服务器时，自动改用同一域名下的前端；
+  前端和后端不在同一个域名时用 --web 指定，例如 --web https://boot.example.com
+
+打不开浏览器时（SSH、没有图形界面的 Linux）：
+  在终端里：把浏览器地址栏的地址粘贴回终端即可
+  被 AI 调用：命令打印授权链接后退出（退出码 2），用户授权后执行 jeecg auth complete "<地址>"；也可以加 --manual 主动这样做`;
+
+const VALUE_OPTIONS = ['host', 'scope', 'type', 'web'];
 
 function parseArgs(argv) {
   const args = { _: [] };
@@ -30,6 +40,8 @@ function parseArgs(argv) {
     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') {
@@ -47,7 +59,8 @@ function parseArgs(argv) {
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   const [group, cmd] = args._;
-  const handler = group === 'auth' ? { login: auth.login, status: auth.status, token: auth.token, logout: auth.logout }[cmd] : null;
+  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;

package/lib/auth.js

@@ -1,12 +1,15 @@
 'use strict';
 /**
- * jeecg auth login / status / token / logout
+ * 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
+ * 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
@@ -16,6 +19,7 @@ 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';
@@ -25,6 +29,8 @@ const LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
 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';
 
 /**
@@ -34,7 +40,7 @@ const HOST_EXAMPLE = 'JeecgBoot / 敲敲云 http://127.0.0.1:8080/jeecg-boot，
  * - jimureport：积木是嵌在宿主应用里的，接口挂在 /jmreport 下，例如 http://127.0.0.1:8085/jmreport/oauth2/token
  */
 const PRODUCTS = {
-  'jeecgboot': { name: 'JeecgBoot', prefix: '' },
+  jeecgboot: { name: 'JeecgBoot', prefix: '' },
   qiaoqiaoyun: { name: '敲敲云', prefix: '' },
   jimureport: { name: '积木报表', prefix: '/jmreport' },
 };
@@ -44,7 +50,9 @@ 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);
-  console.error(successText(cred));
+  if (cred) {
+    console.error(successText(cred));
+  }
 }
 
 /**
@@ -66,11 +74,33 @@ async function token(args) {
     return;
   }
   console.error(cred ? `登录已过期或已被撤销（${host}），重新授权：` : `还没有登录 ${host}，开始授权：`);
-  const fresh = await browserLogin(host, type || (cred && cred.type), args, AUTO_LOGIN_TIMEOUT_MS);
+  const fresh = await browserLogin(host, type || (cred && cred.type), { ...args, web: args.web || (cred && cred.web) }, 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 给程序读地址、产品和租户
  */
@@ -108,15 +138,19 @@ async function logout(args) {
     console.log(`本机没有 ${host} 的登录信息`);
     return;
   }
-  try {
-    await fetch(cred.revocationEndpoint, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-      body: new URLSearchParams({ token: cred.refreshToken, client_id: CLIENT_ID }),
-    });
-  } catch (e) {
-    console.log(`服务器撤销失败（${e.message}），只删除了本机凭证`);
+  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;
@@ -126,7 +160,7 @@ async function logout(args) {
 }
 
 /**
- * 浏览器授权登录，成功后保存凭证并设为默认地址
+ * 浏览器授权登录，成功后保存凭证并设为默认地址；打不开浏览器又不在终端里时返回 null（改由 jeecg auth complete 完成）
  */
 async function browserLogin(host, type, args, timeoutMs) {
   // 1. 按产品标识请求对应的授权配置；没给标识时按 DETECT_ORDER 依次探测
@@ -144,64 +178,83 @@ 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 tokenEndpoint = `${base}/oauth2/token`;
-  const revocationEndpoint = `${base}/oauth2/revoke`;
-  warnLocalAuthorizePage(meta.authorization_endpoint, host);
-
-  // 2. 本机起回调服务，打开授权页
-  const verifier = crypto.randomBytes(32).toString('base64url');
-  const challenge = crypto.createHash('sha256').update(verifier).digest('base64url');
-  const state = crypto.randomBytes(16).toString('base64url');
-  const callback = await startCallbackServer(state);
-  const redirectUri = `http://127.0.0.1:${callback.port}/callback`;
+  const web = args.web ? normalizeHost(args.web) : null;
+  const login = {
+    host,
+    type,
+    web,
+    verifier: crypto.randomBytes(32).toString('base64url'),
+    state: crypto.randomBytes(16).toString('base64url'),
+    tokenEndpoint: `${base}/oauth2/token`,
+    revocationEndpoint: `${base}/oauth2/revoke`,
+    authorizeEndpoint: await resolveAuthorizeEndpoint(meta, host, type, web),
+  };
 
-  const params = new URLSearchParams({
-    response_type: 'code',
-    client_id: CLIENT_ID,
-    redirect_uri: redirectUri,
-    code_challenge: challenge,
-    code_challenge_method: 'S256',
-    state,
-  });
-  if (args.scope) {
-    params.set('scope', args.scope);
+  // 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(login, args.scope)}\n`);
+    console.error('授权后浏览器会跳到一个打不开的 127.0.0.1 地址，把地址栏里的完整地址交给：jeecg auth complete "<地址>"');
+    process.exitCode = MANUAL_EXIT_CODE;
+    return null;
   }
-  const authorizeUrl = `${meta.authorization_endpoint}?${params}`;
-  console.error(`请在浏览器中确认授权（${PRODUCTS[type].name}）：\n${authorizeUrl}\n`);
-  if (args.open !== false) {
-    openBrowser(authorizeUrl);
+
+  // 3. 本机起回调服务，打开授权页
+  const callback = await startCallbackServer(login.state);
+  login.redirectUri = `http://127.0.0.1:${callback.port}/callback`;
+  console.error(`请在浏览器中确认授权（${PRODUCTS[type].name}）：\n${authorizeUrl(login, args.scope)}\n`);
+  const browserOpened = args.open !== false && hasLocalBrowser();
+  if (browserOpened) {
+    openBrowser(authorizeUrl(login, args.scope));
   }
+  // 在终端里又没自动打开浏览器（--no-open、SSH）：浏览器跳回时可能打不开，也可以把地址栏的地址粘贴回来
+  const paste = !browserOpened && process.stdin.isTTY ? waitForPaste(login.state) : null;
 
-  // 3. 等用户点「授权」，用授权码换 token
+  // 4. 等用户点「授权」，用授权码换 token
   let code;
   try {
-    code = await callback.waitForCode(timeoutMs);
+    code = await (paste ? Promise.race([callback.waitForCode(timeoutMs), paste.promise]) : callback.waitForCode(timeoutMs));
   } finally {
     callback.close();
+    if (paste) {
+      paste.close();
+    }
   }
-  const t = await requestToken(tokenEndpoint, {
+  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: verifier,
-    redirect_uri: redirectUri,
+    code_verifier: login.verifier,
+    redirect_uri: login.redirectUri,
     client_id: CLIENT_ID,
   });
-
   const data = store.load();
-  data.hosts[host] = toCredential(t, type, tokenEndpoint, revocationEndpoint);
-  data.defaultHost = host;
+  data.hosts[login.host] = toCredential(t, login.host, login.type, login.tokenEndpoint, login.revocationEndpoint, login.web);
+  data.defaultHost = login.host;
   store.save(data);
-  return data.hosts[host];
+  return data.hosts[login.host];
 }
 
 /**
- * 用 refresh_token 换新 token；登录已过期或被撤销时返回 null（由调用方重新授权）
+ * 用 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: cred.refreshToken, client_id: CLIENT_ID });
+    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, typeOf(cred), cred.tokenEndpoint, cred.revocationEndpoint);
+    data.hosts[host] = toCredential(t, host, typeOf(cred), cred.tokenEndpoint, cred.revocationEndpoint, cred.web);
     store.save(data);
     return data.hosts[host];
   } catch (e) {
@@ -209,9 +262,10 @@ async function refresh(host, cred) {
       throw e;
     }
     // refresh_token 每次刷新都会换新的：两个脚本同时刷新时后到的会失败，先看看另一个进程是不是已经刷新好了
+    // （比 accessToken：refresh_token 存进钥匙串时记录里只有 keychain: 标记，前后一样，比不出来）
     await new Promise((r) => setTimeout(r, 1000));
     const latest = store.load().hosts[host];
-    return latest && latest.refreshToken !== cred.refreshToken ? latest : null;
+    return latest && latest.accessToken !== cred.accessToken ? latest : null;
   }
 }
 
@@ -219,7 +273,7 @@ async function refresh(host, cred) {
  * 地址和产品标识：--host 优先，其次上次登录的地址；都没有时在终端里提示输入（第一次使用）
  */
 async function resolveTarget(args, allowPrompt) {
-  let type = args.type || null;
+  const type = args.type || null;
   if (type && !PRODUCTS[type]) {
     throw new Error(`不认识的 --type：${type}，可选 ${Object.keys(PRODUCTS).join(' / ')}`);
   }
@@ -236,10 +290,10 @@ async function resolveTarget(args, allowPrompt) {
       throw new Error(`还没有登录过，请用 --host 指定地址（${HOST_EXAMPLE}）`);
     }
   }
-  // 积木地址常带着 /jmreport（例如从浏览器复制的 http://127.0.0.1:8085/jmreport），统一存应用地址，接口前缀按标识拼
-  if (/\/jmreport$/i.test(host) && (!type || type === 'jimureport')) {
+  // 积木地址常带着 /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);
-    type = 'jimureport';
   }
   return { host, type };
 }
@@ -267,6 +321,139 @@ async function fetchMetadata(host, prefix) {
   return res.ok && meta.authorization_endpoint && meta.token_endpoint ? meta : null;
 }
 
+function authorizeUrl(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 `${login.authorizeEndpoint}?${params}`;
+}
+
+/**
+ * 授权页地址：
+ * - 积木：授权页就在积木自己的地址下，直接用 --host 拼（反向代理改了路径时，后端按请求算出来的地址外网访问不到）
+ * - JeecgBoot / 敲敲云：授权页在前端，地址来自后端配置 jeecg.domainUrl.pc（默认 http://localhost:3100）。
+ *   服务器上没改这个配置时，浏览器会打开用户自己电脑上的 localhost，而不是服务器上的前端；
+ *   这时看 --host 同一个域名下有没有这个后端的前端，有就改用它；也可以用 --web 直接指定前端地址
+ */
+async function resolveAuthorizeEndpoint(meta, host, type, web) {
+  if (type === 'jimureport') {
+    return `${host}${PRODUCTS.jimureport.prefix}/oauth2/authorize`;
+  }
+  if (web) {
+    return `${web}/oauth2/authorize`;
+  }
+  const endpoint = meta.authorization_endpoint;
+  if (!isLocalUrl(endpoint) || isLocalUrl(host)) {
+    return endpoint;
+  }
+  const origin = new URL(host).origin;
+  if (await isFrontendOf(origin, host)) {
+    console.error(`后端配置的授权页是 ${new URL(endpoint).origin}（服务器上没配 jeecg.domainUrl.pc），已改用同一域名下的前端 ${origin}\n`);
+    return `${origin}/oauth2/authorize`;
+  }
+  console.error(`注意：后端返回的授权页是 ${new URL(endpoint).origin}，服务器上可能没配置 jeecg.domainUrl.pc（要配成前端的外网地址）。`);
+  console.error('可以加 --web <前端地址> 指定前端，例如 --web https://boot.example.com\n');
+  return endpoint;
+}
+
+/**
+ * 前端打包后根目录有 _app.config.js，里面记着前端调用的后端地址（VITE_GLOB_API_URL 是相对路径，例如 /jeecgboot；
+ * VITE_GLOB_DOMAIN_URL 是完整地址），和 --host 对得上才算是这个后端的前端，避免把用户带到别的系统
+ */
+async function isFrontendOf(origin, host) {
+  try {
+    const res = await fetch(`${origin}/_app.config.js`);
+    if (!res.ok) {
+      return false;
+    }
+    const text = await res.text();
+    const apiUrl = (text.match(/"VITE_GLOB_API_URL"\s*:\s*"([^"]*)"/) || [])[1];
+    const domainUrl = (text.match(/"VITE_GLOB_DOMAIN_URL"\s*:\s*"([^"]*)"/) || [])[1];
+    const trim = (u) => u.replace(/\/+$/, '');
+    return (apiUrl != null && trim(origin + apiUrl) === host) || (domainUrl != null && trim(domainUrl) === host);
+  } catch (e) {
+    return false;
+  }
+}
+
+function isLocalUrl(url) {
+  return /^https?:\/\/(localhost|127\.0\.0\.1)(:|\/|$)/i.test(url);
+}
+
+/**
+ * 解析浏览器地址栏里的回调地址，例如 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 地址`;
@@ -283,18 +470,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',
@@ -311,14 +486,16 @@ async function requestToken(endpoint, form) {
   return body;
 }
 
-function toCredential(t, type, tokenEndpoint, revocationEndpoint) {
+function toCredential(t, host, type, tokenEndpoint, revocationEndpoint, web) {
   return {
     type,
+    // 用 --web 指定过的前端地址，之后自动重新授权时还用它
+    web: web || null,
     username: t.username,
     tenantId: t.tenant_id == null ? null : t.tenant_id,
     scope: t.scope || null,
     accessToken: t.access_token,
-    refreshToken: t.refresh_token,
+    refreshToken: secret.protect(host, t.refresh_token),
     expiresAt: Date.now() + Number(t.expires_in || 0) * 1000,
     tokenEndpoint,
     revocationEndpoint,
@@ -416,4 +593,4 @@ function prompt(question) {
   );
 }
 
-module.exports = { login, status, token, logout };
+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

@@ -1,7 +1,9 @@
 'use strict';
 /**
- * 本机凭证：按后端地址存在 ~/.jeecg/credentials.json（文件权限 600）
- * 结构：{ defaultHost, hosts: { "<后端地址>": { username, tenantId, accessToken, refreshToken, expiresAt, ... } } }
+ * 本机凭证：按地址存在 ~/.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');
@@ -9,6 +11,7 @@ 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 {
@@ -20,10 +23,34 @@ function load() {
 }
 
 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 });
+  fs.writeFileSync(file, JSON.stringify(data, null, 2), { mode: 0o600 });
   // 文件已存在时 writeFileSync 不会改权限，这里再收紧一次（Windows 上由用户目录的 ACL 保护）
-  fs.chmodSync(FILE, 0o600);
+  fs.chmodSync(file, 0o600);
 }
 
-module.exports = { load, save, FILE };
+module.exports = { load, save, loadPending, savePending, clearPending, FILE };

package/package.json

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