neo-cmp-cli 1.7.3 → 1.7.5-beta.1

package/src/neo/neoLogin.js

@@ -0,0 +1,451 @@
+const axios = require('axios');
+const fs = require('fs');
+const path = require('path');
+const ora = require('ora');
+const http = require('http');
+const url = require('url');
+const open = require('open');
+const portfinder = require('portfinder');
+const { errorLog, successLog } = require('../utils/common');
+const neoAuthConfig = require('../config/auth.config');
+
+/**
+ * Neo 登录授权服务类
+ * 实现 OAuth2 授权码模式的登录/登出功能
+ */
+class NeoLoginService {
+  /**
+   * 初始化登录服务
+   * @param {object} config 授权配置信息
+   * @param {string} config.loginURL 登录授权 URL
+   * @param {string} config.tokenAPI Token 获取接口地址
+   * @param {string} config.response_type 认证类型 (code)
+   * @param {string} config.client_id 客户端 ID
+   * @param {string} config.client_secret 客户端秘钥
+   * @param {string} config.scope 授权范围 (all)
+   * @param {string} config.oauthType OAuth 类型 (standard)
+   * @param {string} config.access_type 访问类型 (offline/online)
+   * @param {string} config.grant_type 授权类型 (authorization_code)
+   */
+  constructor(config = {}) {
+    const { loginURL, tokenAPI } = config;
+
+    // 验证必需的配置项
+    if (!loginURL || !tokenAPI) {
+      throw new Error('auth.config.js 配置不完整，需要包含 loginURL、tokenAPI');
+    }
+
+    this.loginURL = loginURL;
+    this.tokenAPI = tokenAPI;
+    this.response_type = neoAuthConfig.response_type || 'code';
+    this.client_id = neoAuthConfig.client_id;
+    this.client_secret = neoAuthConfig.client_secret;
+    this.scope = neoAuthConfig.scope || 'all';
+    this.oauthType = neoAuthConfig.oauthType || 'standard';
+    this.access_type = neoAuthConfig.access_type || 'offline';
+    this.grant_type = neoAuthConfig.grant_type || 'authorization_code';
+
+    // Token 存储路径（在当前项目根目录的 .neo-cli 文件夹下）
+    this.tokenDir = path.join(process.cwd(), '.neo-cli');
+    this.tokenFile = path.join(this.tokenDir, 'token.json');
+  }
+
+  /**
+   * 确保 token 存储目录存在
+   */
+  ensureTokenDir() {
+    if (!fs.existsSync(this.tokenDir)) {
+      fs.mkdirSync(this.tokenDir, { recursive: true });
+    }
+  }
+
+  /**
+   * 保存 token 到本地文件
+   * @param {object} tokenData Token 数据
+   */
+  saveToken(tokenData) {
+    this.ensureTokenDir();
+    const tokenInfo = {
+      ...tokenData,
+      savedAt: Date.now(),
+      expiresAt: Date.now() + (tokenData.expires_in || 7200) * 1000
+    };
+    fs.writeFileSync(this.tokenFile, JSON.stringify(tokenInfo, null, 2), 'utf-8');
+  }
+
+  /**
+   * 读取本地保存的 token
+   * @returns {object|null} Token 数据，如果不存在或已过期则返回 null
+   */
+  readToken() {
+    if (!fs.existsSync(this.tokenFile)) {
+      return null;
+    }
+
+    try {
+      const tokenData = JSON.parse(fs.readFileSync(this.tokenFile, 'utf-8'));
+      return tokenData;
+    } catch (error) {
+      errorLog(`读取 token 文件失败: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * 检查 token 是否过期
+   * @param {object} tokenData Token 数据
+   * @returns {boolean} true 表示已过期，false 表示未过期
+   */
+  isTokenExpired(tokenData) {
+    if (!tokenData || !tokenData.expiresAt) {
+      return true;
+    }
+    // 提前 5 分钟判断为过期，避免边缘情况
+    return Date.now() >= tokenData.expiresAt - 5 * 60 * 1000;
+  }
+
+  /**
+   * 清除本地保存的 token
+   */
+  clearToken() {
+    if (fs.existsSync(this.tokenFile)) {
+      fs.unlinkSync(this.tokenFile);
+    }
+  }
+
+  /**
+   * 生成回调地址
+   * @param {number} port 端口号
+   * @returns {string} 回调地址
+   */
+  getRedirectURI(port) {
+    return `http://localhost:${port}/callback`;
+  }
+
+  /**
+   * 构建授权 URL
+   * @param {string} redirectUri 回调地址
+   * @returns {string} 授权 URL
+   */
+  buildAuthUrl(redirectUri) {
+    const params = new URLSearchParams({
+      response_type: this.response_type,
+      client_id: this.client_id,
+      redirect_uri: redirectUri,
+      scope: this.scope,
+      oauthType: this.oauthType,
+      access_type: this.access_type
+    });
+
+    return `${this.loginURL}?${params.toString()}`;
+  }
+
+  /**
+   * 打开浏览器访问授权 URL
+   * @param {string} authUrl 授权 URL
+   */
+  async openBrowser(authUrl) {
+    try {
+      await open(authUrl);
+    } catch (error) {
+      errorLog(`无法自动打开浏览器: ${error.message}`);
+      console.log(`\n请手动访问以下 URL 进行授权:\n${authUrl}\n`);
+    }
+  }
+
+  /**
+   * 启动本地服务器接收授权码（code）
+   * @returns {Promise<{redirectUri: string, codePromise: Promise<string>}>} 回调地址和授权码Promise
+   */
+  async startCallbackServer() {
+    // 使用 portfinder 获取可用端口
+    const port = await portfinder.getPortPromise({
+      port: 8888, // 起始端口
+      stopPort: 9999 // 结束端口
+    });
+
+    // 使用获取到的端口生成 redirect_uri
+    const redirectUri = this.getRedirectURI(port);
+    const redirectUrl = new URL(redirectUri);
+
+    const codePromise = new Promise((resolve, reject) => {
+      const server = http.createServer((req, res) => {
+        const parsedUrl = url.parse(req.url, true);
+
+        if (parsedUrl.pathname === redirectUrl.pathname || parsedUrl.pathname === '/') {
+          const code = parsedUrl.query.code;
+          const error = parsedUrl.query.error;
+
+          if (error) {
+            res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end(`
+              <html>
+                <head><title>授权失败</title></head>
+                <body>
+                  <h1>授权失败</h1>
+                  <p>错误信息: ${error}</p>
+                  <p>您可以关闭此窗口</p>
+                </body>
+              </html>
+            `);
+            server.close();
+            reject(new Error(`授权失败: ${error}`));
+            return;
+          }
+
+          if (code) {
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end(`
+              <html>
+                <head><title>授权成功</title></head>
+                <body>
+                  <h1>授权成功!</h1>
+                  <p>已获取授权码，正在获取 token...</p>
+                  <p>您可以关闭此窗口</p>
+                  <script>window.close();</script>
+                </body>
+              </html>
+            `);
+            server.close();
+            resolve(code);
+            return;
+          }
+
+          res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+          res.end(`
+            <html>
+              <head><title>授权失败</title></head>
+              <body>
+                <h1>授权失败</h1>
+                <p>未获取到授权码</p>
+                <p>您可以关闭此窗口</p>
+              </body>
+            </html>
+          `);
+          server.close();
+          reject(new Error('未获取到授权码'));
+        } else {
+          res.writeHead(404, { 'Content-Type': 'text/plain' });
+          res.end('Not Found');
+        }
+      });
+
+      server.on('error', (error) => {
+        if (error.code === 'EADDRINUSE') {
+          reject(new Error(`端口 ${port} 已被占用，无法启动回调服务器`));
+        } else {
+          reject(error);
+        }
+      });
+
+      server.listen(port, () => {
+        console.log(`\n本地回调服务器已启动，监听端口: ${port}`);
+        console.log(`回调地址: ${redirectUri}`);
+      });
+
+      // 设置超时（5 分钟）
+      setTimeout(() => {
+        server.close();
+        reject(new Error('授权超时，请重试'));
+      }, 5 * 60 * 1000);
+    });
+
+    return { redirectUri, codePromise };
+  }
+
+  /**
+   * 使用授权码获取 token
+   * @param {string} code 授权码
+   * @param {string} redirectUri 回调地址
+   * @returns {Promise<object>} Token 数据
+   */
+  async getTokenByCode(code, redirectUri) {
+    const spinner = ora('正在获取 access token...').start();
+
+    try {
+      const formData = new URLSearchParams();
+      formData.append('grant_type', this.grant_type);
+      formData.append('client_id', this.client_id);
+      formData.append('client_secret', this.client_secret);
+      formData.append('code', code);
+      formData.append('redirect_uri', redirectUri);
+
+      const response = await axios.post(this.tokenAPI, formData.toString(), {
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded'
+        }
+      });
+
+      const tokenData = response.data;
+
+      if (!tokenData || !tokenData.access_token) {
+        errorLog('获取 token 失败：响应中未包含 access_token', spinner);
+        errorLog(`响应数据: ${JSON.stringify(tokenData)}`);
+        process.exit(1);
+      }
+
+      successLog('成功获取 access token', spinner);
+      return tokenData;
+    } catch (error) {
+      errorLog('获取 token 失败', spinner);
+      errorLog(`\n获取 token 失败: ${error.message}`);
+      if (error.response) {
+        errorLog(`响应数据: ${JSON.stringify(error.response.data)}`);
+      }
+      process.exit(1);
+    }
+  }
+
+  /**
+   * 使用 refresh_token 刷新 token
+   * @param {string} refreshToken Refresh Token
+   * @returns {Promise<object>} 新的 Token 数据
+   */
+  async refreshToken(refreshToken) {
+    const spinner = ora('正在刷新 token...').start();
+
+    try {
+      const formData = new URLSearchParams();
+      formData.append('grant_type', 'refresh_token');
+      formData.append('client_id', this.client_id);
+      formData.append('client_secret', this.client_secret);
+      formData.append('refresh_token', refreshToken);
+
+      const response = await axios.post(this.tokenAPI, formData.toString(), {
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded'
+        }
+      });
+
+      const tokenData = response.data;
+
+      if (!tokenData || !tokenData.access_token) {
+        errorLog('刷新 token 失败：响应中未包含 access_token', spinner);
+        errorLog(`响应数据: ${JSON.stringify(tokenData)}`);
+        return null;
+      }
+
+      successLog('Token 刷新成功', spinner);
+      return tokenData;
+    } catch (error) {
+      errorLog('刷新 token 失败', spinner);
+      errorLog(`\n刷新 token 失败: ${error.message}`);
+      if (error.response) {
+        errorLog(`响应数据: ${JSON.stringify(error.response.data)}`);
+      }
+      return null;
+    }
+  }
+
+  /**
+   * 执行登录流程
+   */
+  async login() {
+    console.log('\n========== NeoCRM 登录授权 ==========\n');
+
+    try {
+      // 1. 启动本地回调服务器（自动获取可用端口）
+      const { redirectUri, codePromise } = await this.startCallbackServer();
+
+      // 2. 构建授权 URL
+      const authUrl = this.buildAuthUrl(redirectUri);
+      console.log('授权 URL:', authUrl);
+
+      // 3. 打开浏览器进行授权
+      console.log('\n正在打开浏览器进行授权...');
+      await this.openBrowser(authUrl);
+
+      // 4. 等待获取授权码
+      const code = await codePromise;
+      console.log('\n✓ 已获取授权码');
+
+      // 5. 使用授权码获取 token
+      const tokenData = await this.getTokenByCode(code, redirectUri);
+
+      // 6. 保存 token 到本地
+      this.saveToken(tokenData);
+
+      console.log('\n========== 登录成功 ==========\n');
+      console.log(`Token 已保存到: ${this.tokenFile}`);
+      console.log(`实例地址: ${tokenData.instance_uri || '未返回'}`);
+      console.log(`租户 ID: ${tokenData.tenant_id || '未返回'}`);
+      console.log(`Token 有效期: ${tokenData.expires_in || 7200} 秒`);
+      console.log(`Refresh Token 有效期: ${tokenData.refresh_token_expires_in || 2592000} 秒`);
+      console.log('');
+
+      return tokenData;
+    } catch (error) {
+      errorLog(`\n登录失败: ${error.message}`);
+      process.exit(1);
+    }
+  }
+
+  /**
+   * 执行登出流程
+   */
+  async logout() {
+    console.log('\n========== NeoCRM 登出 ==========\n');
+
+    if (!fs.existsSync(this.tokenFile)) {
+      console.log('当前未登录，无需登出。');
+      return;
+    }
+
+    try {
+      this.clearToken();
+      successLog(`已清除 token 文件: ${this.tokenFile}`);
+      console.log('\n登出成功！\n');
+    } catch (error) {
+      errorLog(`登出失败: ${error.message}`);
+      process.exit(1);
+    }
+  }
+
+  /**
+   * 获取有效的 token（自动刷新）
+   * @returns {Promise<object>} Token 数据
+   */
+  async getValidToken() {
+    const tokenData = this.readToken();
+
+    if (!tokenData) {
+      errorLog('未找到本地 token，请先执行 neo login 进行登录');
+      process.exit(1);
+    }
+
+    // 检查 token 是否过期
+    if (this.isTokenExpired(tokenData)) {
+      console.log('Token 已过期，正在尝试刷新...');
+
+      if (!tokenData.refresh_token) {
+        errorLog('Refresh token 不存在，请重新登录');
+        process.exit(1);
+      }
+
+      // 使用 refresh_token 刷新
+      const newTokenData = await this.refreshToken(tokenData.refresh_token);
+
+      if (!newTokenData) {
+        errorLog('Token 刷新失败，请重新登录 (neo login)');
+        process.exit(1);
+      }
+
+      // 保存新的 token
+      this.saveToken(newTokenData);
+      return newTokenData;
+    }
+
+    return tokenData;
+  }
+
+  /**
+   * 获取 access token 字符串
+   * @returns {Promise<string>} Access Token
+   */
+  async getAccessToken() {
+    const tokenData = await this.getValidToken();
+    return tokenData.access_token;
+  }
+}
+
+module.exports = NeoLoginService;

package/src/neo/neoService.js

@@ -5,12 +5,14 @@ const path = require('path');
 const ora = require('ora');
 const _ = require('lodash');
 const { resolve } = require('akfun');
+const NeoLoginService = require('./neoLogin');
 const updatePublishLog = require('../utils/projectUtils/updatePublishLog');
 const { getFramework, errorLog, successLog } = require('../utils/common');
 
 // NeoCRM 平台默认 API 配置
 const NeoCrmAPI = {
   neoBaseURL: 'https://crm.xiaoshouyi.com', // 平台根地址
+  loginAPI: 'https://login-cd.xiaoshouyi.com/auc/oauth2/auth', // code 获取接口地址
   tokenAPI: 'https://login.xiaoshouyi.com/auc/oauth2/token', // Token 获取接口地址
   uploadAPI: '/rest/metadata/v3.0/ui/customComponents/actions/upload', // 文件上传接口地址
   delete: '/rest/metadata/v3.0/ui/customComponents',
@@ -48,28 +50,47 @@ class NeoService {
   /**
    * 初始化 Neo 服务
    * @param {object} config 配置信息
+   * @param {string} config.authType 授权类型，可选值：oauth2（默认）、password
    * @param {string} config.neoBaseURL Neo 平台根地址
    * @param {string} config.tokenAPI Token 获取接口地址
+   * @param {string} config.loginURL OAuth2 登录授权 URL（OAuth2 模式需要）
    * @param {object} config.auth 授权信息
    * @param {string} config.auth.client_id 客户端 ID
    * @param {string} config.auth.client_secret 客户端密钥
-   * @param {string} config.auth.username 用户名
-   * @param {string} config.auth.password 密码
+   * @param {string} config.auth.username 用户名（password 模式需要）
+   * @param {string} config.auth.password 密码（password 模式需要）
    */
   constructor(config = {}) {
-    const { assetsRoot, neoBaseURL, tokenAPI, auth } = config || {};
+    const { assetsRoot, neoBaseURL, tokenAPI, loginURL, auth, authType } = config || {};
+
+    // 设置授权类型，默认为 oauth2
+    this.authType = authType || 'oauth2';
+
     if (!auth) {
       throw new Error('auth 不能为空');
     }
-    if (!auth.client_id || !auth.client_secret || !auth.username || !auth.password) {
-      throw new Error(
-        'neoConfig / auth 配置不完整，需要包含 client_id、client_secret、username、password'
-      );
+
+    // 根据授权类型验证必需的配置项
+    if (this.authType === 'password') {
+      if (!auth.client_id || !auth.client_secret || !auth.username || !auth.password) {
+        throw new Error(
+          'neo.config.js / neoConfig / auth 配置不完整（password 模式），需要包含 client_id、client_secret、username、password'
+        );
+      }
+    } else if (this.authType === 'oauth2') {
+      if (!loginURL || !tokenAPI) {
+        throw new Error(
+          'neo.config.js / neoConfig 配置不完整（oauth2 模式），需要包含 loginURL、tokenAPI 配置。'
+        );
+      }
+    } else {
+      throw new Error(`不支持的授权类型: ${this.authType}，可选值：oauth2、password`);
     }
 
     this.assetsRoot = assetsRoot || resolve('dist');
     this.neoBaseURL = neoBaseURL || NeoCrmAPI.neoBaseURL;
     this.tokenAPI = tokenAPI || NeoCrmAPI.tokenAPI;
+    this.loginURL = loginURL || NeoCrmAPI.loginAPI;
     this.auth = auth;
     this.cmpList = [];
     this.cmpInfoMap = {};
@@ -117,10 +138,30 @@ class NeoService {
 
   /**
    * 获取 token（含授权信息、租户信息）
+   * 根据 authType 自动选择授权模式：oauth2 或 password
    * @returns {Promise<string>} token
    */
   async getToken() {
-    const spinner = ora('获取 token...').start();
+    // 检查缓存是否有效
+    if (!this.isTokenExpired()) {
+      return this.tokenCache.token;
+    }
+
+    // 根据授权类型选择对应的获取方式
+    if (this.authType === 'oauth2') {
+      return await this.getTokenByOAuth2();
+    } else {
+      return await this.getTokenByPassword();
+    }
+  }
+
+  /**
+   * 使用密码模式获取 token
+   * @returns {Promise<string>} token
+   */
+  async getTokenByPassword() {
+    const spinner = ora('获取 token（密码模式）...').start();
+
     // 检查缓存是否有效
     if (!this.isTokenExpired()) {
       successLog('使用缓存的 token。', spinner);
@@ -176,6 +217,43 @@ class NeoService {
     }
   }
 
+  /**
+   * 获取 OAuth2 授权码模式的 token
+   * @returns {Promise<string>} token
+   */
+  async getTokenByOAuth2() {
+    const spinner = ora('获取 token（OAuth2 模式）...').start();
+
+    try {
+      // 构建 OAuth2 配置
+      const oauth2Config = {
+        loginURL: this.loginURL,
+        tokenAPI: this.tokenAPI
+      };
+
+      const loginService = new NeoLoginService(oauth2Config);
+      const accessToken = await loginService.getAccessToken();
+
+      // 缓存 token（OAuth2 模式下的 token 有效期由 NeoLoginService 管理）
+      // 这里我们设置一个较长的过期时间，实际过期检查由 NeoLoginService 内部处理
+      this.tokenCache = {
+        token: accessToken,
+        expiresAt: Date.now() + 7200 * 1000 // 默认 2 小时，实际由 NeoLoginService 管理
+      };
+
+      spinner.clear();
+      spinner.stop();
+      return accessToken;
+    } catch (error) {
+      errorLog('获取 token 失败（OAuth2 模式）', spinner);
+      errorLog(`\n获取 token 失败: ${error.message}`);
+      if (error.response) {
+        errorLog(`响应数据: ${JSON.stringify(error.response.data)}`);
+      }
+      process.exit(1);
+    }
+  }
+
   /**
    * 刷新 token
    * @returns {Promise<string>} 新的 token

package/src/template/antd-custom-cmp-template/neo.config.js

@@ -103,22 +103,31 @@ module.exports = {
     }
     */
   },
-  // NeoCRM 平台配置
+  // 授权码授权模式下的 NeoCRM 平台配置
   neoConfig: {
+    authType: 'oauth2', // 授权类型，可选值：oauth2（默认）、password
     neoBaseURL: 'https://crm-cd.xiaoshouyi.com', // 平台根地址（默认：https://crm.xiaoshouyi.com）
+    //  当 authType 为 oauth2 时，loginURL 配置项必填
+    loginURL: 'https://login-cd.xiaoshouyi.com/auc/oauth2/auth', // 登录授权 URL（默认：https://login.xiaoshouyi.com/auc/oauth2/auth）
     tokenAPI: 'https://login-cd.xiaoshouyi.com/auc/oauth2/token', // Token 获取接口地址（默认：https://login.xiaoshouyi.com/auc/oauth2/token）
-    // NeoCRM 授权配置
+  },
+  /*
+  // 密码授权模式下的 NeoCRM 平台配置
+  neoConfig: {
+    authType: 'password', // 授权类型，可选值：oauth2（默认）、password
+    neoBaseURL: 'https://crm-cd.xiaoshouyi.com', // 平台根地址（默认：https://crm.xiaoshouyi.com）
+    tokenAPI: 'https://login-cd.xiaoshouyi.com/auc/oauth2/token', // Token 获取接口地址（默认：https://login.xiaoshouyi.com/auc/oauth2/token）
+    // 当 authType 为 password 时，auth 配置项必填
     auth: {
-      client_id: 'xx', // 客户端 ID，从创建连接器的客户端信息中获取（Client_Id）
-      client_secret: 'xxx', // 客户端秘钥，从创建连接器的客户端信息中获取（Client_Secret）
-      username: 'xx', // 用户在销售易系统中的用户名
-      /**
-       * password 为 用户在销售易系统中的账号密码加上 8 位安全令牌。
-       * 例如，用户密码为 123456，安全令牌为 ABCDEFGH，则 password 的值应为 123456ABCDEFGH。
-       */
-      password: 'xx xx', // 用户账户密码 + 8 位安全令牌
+      client_id: auth.client_id || 'xx', // 客户端 ID，从创建连接器的客户端信息中获取（Client_Id）
+      client_secret: auth.client_secret || 'xxx', // 客户端秘钥，从创建连接器的客户端信息中获取（Client_Secret）
+      username: auth.username || 'xx', // 用户在销售易系统中的用户名
+      // password 为 用户在销售易系统中的账号密码加上 8 位安全令牌。
+      // 例如，用户密码为 123456，安全令牌为 ABCDEFGH，则 password 的值应为 123456ABCDEFGH。
+      password: auth.password || 'xx xx', // 用户账户密码 + 8 位安全令牌
     },
   },
+  */
   pushCmp: {
     // 用于构建并发布至 NeoCRM 的相关配置
     /*

package/src/template/antd-custom-cmp-template/package.json

@@ -48,7 +48,7 @@
     "@commitlint/config-conventional": "^9.1.1",
     "@types/react": "^16.9.11",
     "@types/react-dom": "^16.9.15",
-    "neo-cmp-cli": "^1.7.3",
+    "neo-cmp-cli": "^1.7.5",
     "husky": "^4.2.5",
     "lint-staged": "^10.2.9",
     "prettier": "^2.0.5"