neo-cmp-cli 1.8.7 → 1.8.9

package/dist/neo/neoLogin.js

@@ -0,0 +1,590 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const require$$0$1 = require('axios');
+const require$$0 = require('node:fs');
+const require$$1 = require('node:path');
+const require$$3 = require('ora');
+const require$$4 = require('node:http');
+const require$$5 = require('node:url');
+const require$$2 = require('open');
+const require$$7 = require('node:net');
+require('portfinder');
+const common = require('../utils/common.js');
+const auth_config = require('../config/auth.config.js');
+
+var neoLogin;
+var hasRequiredNeoLogin;
+
+function requireNeoLogin () {
+	if (hasRequiredNeoLogin) return neoLogin;
+	hasRequiredNeoLogin = 1;
+	const axios = require$$0$1;
+	const fs = require$$0;
+	const path = require$$1;
+	const ora = require$$3;
+	const http = require$$4;
+	const url = require$$5;
+	const open = require$$2;
+	const net = require$$7;
+	const { errorLog, successLog } = common.__require();
+	const neoAuthConfig = auth_config.__require();
+
+	/**
+	 * 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}`;
+	  }
+
+	  /**
+	   * 构建授权 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`);
+	    }
+	  }
+
+	  /**
+	   * 检测端口是否被占用
+	   * @param {number} port 端口号
+	   * @returns {Promise<boolean>} true 表示端口被占用，false 表示端口可用
+	   */
+	  async isPortInUse(port) {
+	    return new Promise((resolve) => {
+	      const server = net.createServer();
+
+	      server.once('error', (err) => {
+	        if (err.code === 'EADDRINUSE') {
+	          resolve(true); // 端口被占用
+	        } else {
+	          resolve(false); // 其他错误，假设端口可用
+	        }
+	      });
+
+	      server.once('listening', () => {
+	        // 端口可用，立即关闭服务器
+	        server.once('close', () => {
+	          resolve(false); // 端口可用
+	        });
+	        server.close();
+	      });
+
+	      server.listen(port);
+	    });
+	  }
+
+	  /**
+	   * 启动本地服务器接收授权码（code）
+	   * @returns {Promise<{redirectUri: string, codePromise: Promise<string>}>} 回调地址和授权码Promise
+	   */
+	  async startCallbackServer() {
+	    let redirectUri = neoAuthConfig.redirectUri;
+	    let redirectUrl = new URL(redirectUri);
+	    let port = parseInt(redirectUrl.port, 10);
+
+	    // 检测端口是否被占用
+	    const portInUse = await this.isPortInUse(port);
+
+	    if (portInUse) {
+	      consoleError(
+	        `\n警告: 端口 ${port} 已被占用，请调整 redirectUri 配置项，使其指向一个未被占用的端口。`
+	      );
+	      process.exit(1);
+	      /*
+	      // 使用 portfinder 查找可用端口
+	      try {
+	        port = await portfinder.getPortPromise({
+	          port: port, // 从配置的端口开始查找
+	          stopPort: 9999 // 结束端口
+	        });
+	        
+	        // 更新 redirectUri 和 redirectUrl
+	        redirectUri = this.getRedirectURI(port);
+	        redirectUrl = new URL(redirectUri);
+	        console.log(`已找到可用端口: ${port}`);
+	        console.log(`回调地址已更新为: ${redirectUri}`);
+	      } catch (error) {
+	        errorLog(`无法找到可用端口: ${error.message}`);
+	        throw new Error(`端口 ${port} 已被占用，且无法找到可用端口`);
+	      }
+	      */
+	    }
+
+	    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>
+                <style>
+                  .container {
+                    margin: 0 auto;
+                    padding-top: 30px;
+                    text-align: center;
+
+                    .error-title {
+                      color: red;
+                    }
+
+                    h1, p {
+                      text-align: center;
+                      margin-top: 30px;
+                    }
+                  }
+                </style>
+                </head>
+                <body>
+                  <div class="container">
+                    <h1 class="error-title">授权失败</h1>
+                    <img src="https://custom-widgets.bj.bcebos.com/neocrmlogin.png" alt="授权失败" />
+                    <p>错误信息: ${error}</p>
+                  </div>
+                </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>
+                <style>
+                  .container {
+                    margin: 0 auto;
+                    padding-top: 30px;
+                    text-align: center;
+
+                    .success-title {
+                      color: green;
+                    }
+
+                    h1, p {
+                      text-align: center;
+                      margin-top: 30px;
+                    }
+                  }
+                </style>
+                </head>
+                <body>
+                  <div class="container">
+                    <h1 class="success-title">授权成功!</h1>
+                    <img src="https://custom-widgets.bj.bcebos.com/neocrmlogin.png" alt="授权成功" />
+                    <p>您已成功授权开发账户，请关闭此页面。</p>
+                  </div>
+                </body>
+              </html>
+            `);
+	            server.close();
+	            resolve(code);
+	            return;
+	          }
+
+	          res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+	          res.end(`
+            <html>
+              <head>
+              <title>授权失败</title>
+              <style>
+                  .container {
+                    margin: 0 auto;
+                    padding-top: 30px;
+                    text-align: center;
+
+                    .error-title {
+                      color: red;
+                    }
+
+                    h1, p {
+                      text-align: center;
+                      margin-top: 30px;
+                    }
+                  }
+                </style>
+              </head>
+              <body>
+                <div class="container">
+                  <h1 class="error-title">授权失败</h1>
+                  <img src="https://custom-widgets.bj.bcebos.com/neocrmlogin.png" alt="授权失败" />
+                  <p>未获取到授权码。</p>
+                </div>
+              </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('刷新授权信息失败：响应中未包含 access_token', spinner);
+	        errorLog(`响应数据: ${JSON.stringify(tokenData)}`);
+	        return null;
+	      }
+
+	      successLog('刷新授权信息成功（token）。', spinner);
+	      return tokenData;
+	    } catch (error) {
+	      errorLog('刷新授权信息失败', spinner);
+	      errorLog(`\n刷新授权信息失败: ${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;
+	      successLog('\n✓ 已获取授权码');
+
+	      // 5. 使用授权码获取 token
+	      const tokenData = await this.getTokenByCode(code, redirectUri);
+
+	      // 6. 保存 token 到本地
+	      this.saveToken(tokenData);
+
+	      console.log('\n========== 登录成功 ==========\n');
+	      console.log(`已缓存授权信息到: ${this.tokenFile}`);
+	      console.log(`实例地址: ${tokenData.instance_uri || '未返回'}`);
+	      console.log(`租户 ID: ${tokenData.tenant_id || '未返回'}`);
+	      console.log(`授权信息有效期（access_token）: ${tokenData.expires_in || 7200} 秒`);
+	      console.log(
+	        `自动刷新授权信息有效期（refresh_token): ${
+	          tokenData.refresh_token_expires_in || 2592000
+	        } 秒`
+	      );
+
+	      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(`已清除授权信息，下次登录需要重新授权。`);
+	      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('未找到授权信息，请先执行 neo login 进行登录。');
+	      process.exit(1);
+	    }
+
+	    // 检查 token 是否过期
+	    if (this.isTokenExpired(tokenData)) {
+	      console.log('授权信息已过期，正在尝试刷新...');
+
+	      if (!tokenData.refresh_token) {
+	        errorLog('自动刷新授权信息失败，请重新登录（neo login）。');
+	        process.exit(1);
+	      }
+
+	      // 使用 refresh_token 刷新
+	      const newTokenData = await this.refreshToken(tokenData.refresh_token);
+
+	      if (!newTokenData) {
+	        errorLog('刷新授权信息失败，请重新登录 (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;
+	  }
+	}
+
+	neoLogin = NeoLoginService;
+	return neoLogin;
+}
+
+exports.__require = requireNeoLogin;

package/dist/neo/neoRequire.js

@@ -0,0 +1,123 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const require$$2 = require('lodash');
+
+var neoRequire_1;
+var hasRequiredNeoRequire;
+
+function requireNeoRequire () {
+	if (hasRequiredNeoRequire) return neoRequire_1;
+	hasRequiredNeoRequire = 1;
+	const _ = require$$2;
+
+	// Neo 共享出来的依赖模块
+	const NeoCommonModules = {
+	  react: '^16.13.1',
+	  'react-dom': '^16.13.1',
+	  mobx: '^6.3.0',
+	  'mobx-react': '^7.0.0',
+	  'mobx-state-tree': '^5.4.0',
+	  echarts: '5.4.2',
+	  antd: '4.9.4',
+	  'antd-mobile': '2.3.4',
+	  '@ant-design/icons': '^4.8.0',
+	  'video-react': '0.14.1',
+	  axios: '^0.27.2',
+	  classnames: '^2.3.2',
+	  qs: '^6.11.0',
+	  lodash: '^4.17.21',
+	  'neo-ui-component-web': '^1.0.0',
+	  'neo-ui-common': '^1.0.0',
+	  'neo-open-api': '^1.0.11',
+	  amis: '^1.1.5',
+	};
+
+	// 根据 Neo 共享出来的依赖模块，获取 externals 配置
+	const getExternalsByNeoCommonModules = (cmpNeoExternals) => {
+	  const externals = {};
+	  Object.keys(NeoCommonModules).forEach(moduleName => {
+	    externals[moduleName] = `commonjs ${moduleName}`;
+	  });
+
+	  // 如果自定义组件有共享的依赖模块，则合并到 externals 中
+	  if (cmpNeoExternals && cmpNeoExternals.length > 0) {
+	    cmpNeoExternals.forEach(moduleName => {
+	      externals[moduleName] = `commonjs ${moduleName}`;
+	    });
+	  }
+	  
+	  return externals;
+	};
+
+	// 用于添加共享的依赖模块
+	const addNeoCommonModules = (modules) => {
+	  if (!window.__NeoCommonModules) {
+	    window.__NeoCommonModules = {};
+	  }
+	  if (isPlainObject(modules)) {
+	    const moduleIds = Object.keys(modules);
+	    moduleIds.forEach((moduleId) => {
+	      const curModule = modules[moduleId];
+	      const curCommonModule = window.__NeoCommonModules[moduleId];
+	      
+	      /**
+	       * 如果 Neo 共享出来的依赖模块已经存在，则合并到 window.__NeoCommonModules 中
+	       * 目的：解决依赖加载顺序问题，确保存在依赖的组件无论其加载顺序如何都能正常运行。
+	       * 
+	       * 疑问1: 为什么 neoRequire 要返回一个 空的默认模块对象？
+	       * 答：组件A 依赖 组件B 时，当 组件A 先加载（挂载对应的 asset 资源脚本）会报错，为了避免挂载时报错返回一个默认的空模块对象。
+	       * 疑问2: 为什么不直接替换已有的模块，而是进行覆盖式合并（保持引用关联）？
+	       * 答：为了避免依赖模块的引用关系被破坏，保持引用关联。确保动态注册进来的模块可以被提前挂载的组件所使用。
+	       */
+	      if (curCommonModule && Object.keys(curCommonModule).length < 3) {
+	        // 如果是默认模块对象，则覆盖式合并（保持引用关联）
+	        window.__NeoCommonModules[moduleId] = Object.assign(window.__NeoCommonModules[moduleId], curModule);
+
+	        // 处理模块中的特殊属性
+	        if (curModule.__esModule !== undefined) {
+	          window.__NeoCommonModules[moduleId].__esModule = curModule.__esModule;
+	        }
+	        if (curModule.default !== undefined) {
+	          window.__NeoCommonModules[moduleId].default = curModule.default;
+	        }
+	      } else {
+	        window.__NeoCommonModules[moduleId] = curModule;
+	      }
+	    });
+	  }
+	};
+
+	// 用于添加自定义组件的远程依赖组件
+	const addNeoRemoteDeps = (remoteDeps) => {
+	  if (!window.__NeoCommonModules) {
+	    window.__NeoCommonModules = {};
+	  }
+	  if (!window.__NeoCommonModules.__neoRemoteDeps) {
+	    window.__NeoCommonModules.__neoRemoteDeps = {};
+	  }
+	  if (_.isPlainObject(remoteDeps)) {
+	    window.__NeoCommonModules.__neoRemoteDeps = Object.assign(window.__NeoCommonModules.__neoRemoteDeps, remoteDeps);
+	  }
+	};
+
+	const initNeoRequire = () => {
+	  if (!window.neoRequire) {
+	    // 用于加载 Neo 共享出来的依赖模块
+	    window.neoRequire = (moduleName) => {
+	      return window.__NeoCommonModules[moduleName] || window[moduleName];
+	    };
+	  }
+	};
+
+	neoRequire_1 = {
+	  initNeoRequire,
+	  addNeoCommonModules,
+	  addNeoRemoteDeps,
+	  getExternalsByNeoCommonModules
+	};
+	return neoRequire_1;
+}
+
+exports.__require = requireNeoRequire;