neo-cmp-cli 1.8.7 → 1.8.9

package/src/neo/neoLogin.js

@@ -1,565 +0,0 @@
-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 net = require('net');
-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}`;
-  }
-
-  /**
-   * 构建授权 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;
-  }
-}
-
-module.exports = NeoLoginService;

package/src/neo/neoRequire.js

@@ -1,125 +0,0 @@
-const _ = require('lodash');
-
-// 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];
-    };
-  }
-};
-
-/**
- * 用于加载 Neo 共享出来的依赖模块
- * @param moduleName 模块名称
- * @returns 模块对象或 undefined
- */
-const neoRequire = (moduleName) => {
-  const defaultModule = { cmpType: moduleName, __esModule: true }; // 默认模块
-  if (!window.__NeoCommonModules) {
-    window.__NeoCommonModules = {}
-  }
-  if (window.__NeoCommonModules[moduleName]) {
-    return window.__NeoCommonModules[moduleName]
-  } else {
-    window.__NeoCommonModules[moduleName] = defaultModule;
-    return window.__NeoCommonModules[moduleName];
-  }
-}
-
-module.exports = {
-  initNeoRequire,
-  addNeoCommonModules,
-  addNeoRemoteDeps,
-  getExternalsByNeoCommonModules
-};