@ws1298191366/cli 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,65 @@
-# 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 status --json                            # 本机登录状态：地址、产品、用户、租户（不输出 token）
+jeecg auth logout [--host <地址>]                   # 撤销授权并删除本机凭证
+```
+
+没有浏览器的环境加 `--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。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,62 @@
+#!/usr/bin/env node
+'use strict';
+const auth = require('../lib/auth');
+
+const USAGE = `jeecg 命令行工具
+
+用法：
+  jeecg auth token [--host <地址>] [--type <产品>] [--scope <权限>] [--no-open]
+      输出可用的 access_token，给脚本用：--token "$(jeecg auth token)"
+      快过期自动刷新；没登录过或登录已失效时自动打开浏览器授权，点「授权」后输出（提示信息打到 stderr，不影响取值）
+  jeecg auth login [--host <地址>] [--type <产品>] [--scope <权限>] [--no-open]
+      只登录（最多等 5 分钟），不输出 token；没有浏览器的环境加 --no-open，自己复制链接打开
+  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`;
+
+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 === '--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 handler = group === 'auth' ? { login: auth.login, status: auth.status, token: auth.token, logout: auth.logout }[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,419 @@
+'use strict';
+/**
+ * jeecg auth login / status / token / 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
+ *
+ * 输出约定：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');
+
+/** 后端内置的公共客户端，没有 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;
+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);
+  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);
+  console.error(successText(fresh));
+  process.stdout.write(fresh.accessToken + '\n');
+}
+
+/**
+ * 只看本机保存的登录信息，不输出 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;
+  }
+  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}），只删除了本机凭证`);
+  }
+  delete data.hosts[host];
+  if (data.defaultHost === host) {
+    data.defaultHost = Object.keys(data.hosts)[0] || null;
+  }
+  store.save(data);
+  console.log(`已退出 ${host}`);
+}
+
+/**
+ * 浏览器授权登录，成功后保存凭证并设为默认地址
+ */
+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 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 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);
+  }
+  const authorizeUrl = `${meta.authorization_endpoint}?${params}`;
+  console.error(`请在浏览器中确认授权（${PRODUCTS[type].name}）：\n${authorizeUrl}\n`);
+  if (args.open !== false) {
+    openBrowser(authorizeUrl);
+  }
+
+  // 3. 等用户点「授权」，用授权码换 token
+  let code;
+  try {
+    code = await callback.waitForCode(timeoutMs);
+  } finally {
+    callback.close();
+  }
+  const t = await requestToken(tokenEndpoint, {
+    grant_type: 'authorization_code',
+    code,
+    code_verifier: verifier,
+    redirect_uri: redirectUri,
+    client_id: CLIENT_ID,
+  });
+
+  const data = store.load();
+  data.hosts[host] = toCredential(t, type, tokenEndpoint, revocationEndpoint);
+  data.defaultHost = host;
+  store.save(data);
+  return data.hosts[host];
+}
+
+/**
+ * 用 refresh_token 换新 token；登录已过期或被撤销时返回 null（由调用方重新授权）
+ */
+async function refresh(host, cred) {
+  try {
+    const t = await requestToken(cred.tokenEndpoint, { grant_type: 'refresh_token', refresh_token: cred.refreshToken, client_id: CLIENT_ID });
+    const data = store.load();
+    data.hosts[host] = toCredential(t, typeOf(cred), cred.tokenEndpoint, cred.revocationEndpoint);
+    store.save(data);
+    return data.hosts[host];
+  } catch (e) {
+    if (e.oauthError !== 'invalid_grant') {
+      throw e;
+    }
+    // refresh_token 每次刷新都会换新的：两个脚本同时刷新时后到的会失败，先看看另一个进程是不是已经刷新好了
+    await new Promise((r) => setTimeout(r, 1000));
+    const latest = store.load().hosts[host];
+    return latest && latest.refreshToken !== cred.refreshToken ? latest : null;
+  }
+}
+
+/**
+ * 地址和产品标识：--host 优先，其次上次登录的地址；都没有时在终端里提示输入（第一次使用）
+ */
+async function resolveTarget(args, allowPrompt) {
+  let 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（例如从浏览器复制的 http://127.0.0.1:8085/jmreport），统一存应用地址，接口前缀按标识拼
+  if (/\/jmreport$/i.test(host) && (!type || type === 'jimureport')) {
+    host = host.slice(0, -'/jmreport'.length);
+    type = 'jimureport';
+  }
+  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 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, 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: 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, status, token, logout };

package/lib/store.js

@@ -0,0 +1,29 @@
+'use strict';
+/**
+ * 本机凭证：按后端地址存在 ~/.jeecg/credentials.json（文件权限 600）
+ * 结构：{ defaultHost, hosts: { "<后端地址>": { username, tenantId, accessToken, refreshToken, expiresAt, ... } } }
+ */
+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');
+
+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) {
+  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, FILE };

package/package.json

@@ -1,6 +1,17 @@
 {
   "name": "@ws1298191366/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "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"
+  }
+}