@htyf-mp/cli 0.2.0-alpha.2 → 0.2.0-alpha.4

package/README.md

@@ -14,7 +14,7 @@ npx @htyf-mp/cli
 
 ### 运行应用程序
 
-进入`mini-apps-template-expo`或`mini-apps-template-taro`或`mini-game-template-cocos`目录并运行:
+进入`mini-apps-template`或`mini-game-template`目录并运行:
 > 具体模板使用，可参考模板内的README.md
 ```sh
 npm start

package/package.json

@@ -1,24 +1,38 @@
 {
   "name": "@htyf-mp/cli",
-  "version": "0.2.0-alpha.2",
+  "version": "0.2.0-alpha.4",
   "description": "红糖云服app小程序模板-cli",
   "type": "module",
   "bin": "src/index.mjs",
+  "files": [
+    "src",
+    "README.md"
+  ],
   "scripts": {
     "start": "node src/index.mjs",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 0"
   },
   "keywords": [
     "hongtangyun",
+    "htyf",
     "mp",
+    "miniprogram",
     "taro",
-    "react-native"
+    "react-native",
+    "expo",
+    "cli",
+    "template"
   ],
   "author": "dgz",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/htyf-mp-community/htyf-mp.git"
+    "url": "https://github.com/htyf-mp-community/htyf-mp.git",
+    "directory": "apps-cli"
+  },
+  "engines": {
+    "node": ">=18.0.0",
+    "npm": ">=9.0.0"
   },
   "dependencies": {
     "@callstack/repack": "^5.1.3",
@@ -38,8 +52,8 @@
     "ora": "^8.2.0",
     "portfinder": "^1.0.37",
     "qrcode": "^1.5.4",
-    "react-native-reanimated": "4.0.1",
-    "react-native-worklets": "^0.4.1",
+    "react-native-reanimated": "4.0.2",
+    "react-native-worklets": "^0.6.1",
     "shelljs": "^0.10.0",
     "superstatic": "^9.2.0",
     "systeminformation": "^5.27.7",

package/src/HtyfImportsPlugin.mjs

@@ -0,0 +1,190 @@
+import path from 'path';
+import fse from 'fs-extra';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const sharedPkg = fse.readJSONSync(path.join(__dirname, '../shared-output.json'));
+
+// 白名单：这些包即使有 native 代码也不需要检查（系统级或已特殊处理）
+const WHITELIST = [];
+
+/**
+ * 从模块路径中提取包名
+ * @param {string} moduleContext - 模块上下文路径
+ * @returns {string|null} 包名，如果无法提取则返回 null
+ */
+function extractPackageName(moduleContext) {
+  if (!moduleContext || !moduleContext.includes('node_modules')) {
+    return null;
+  }
+
+  const parts = moduleContext.split('node_modules/');
+  if (parts.length < 2) {
+    return null;
+  }
+
+  const packagePath = parts[1];
+  const segments = packagePath.split('/').filter(Boolean);
+  
+  if (segments.length === 0) {
+    return null;
+  }
+
+  // 处理 scoped packages (@scope/package)
+  if (segments[0].startsWith('@') && segments.length >= 2) {
+    return `${segments[0]}/${segments[1]}`;
+  }
+
+  return segments[0];
+}
+
+/**
+ * 检查包是否包含 native 代码
+ * @param {string} packageName - 包名
+ * @returns {boolean} 是否包含 native 代码
+ */
+function hasNativeCode(packageName) {
+  const nodeModulesPath = path.join(__dirname, '../node_modules');
+  const iosPath = path.join(nodeModulesPath, packageName, 'ios');
+  const androidPath = path.join(nodeModulesPath, packageName, 'android');
+  
+  return fse.pathExistsSync(iosPath) || fse.pathExistsSync(androidPath);
+}
+
+/**
+ * 检查包是否在共享配置中
+ * @param {string} packageName - 包名
+ * @returns {boolean} 是否在共享配置中
+ */
+function isInSharedConfig(packageName) {
+  return sharedPkg && sharedPkg.hasOwnProperty(packageName);
+}
+
+/**
+ * 检查包是否在白名单中
+ * @param {string} packageName - 包名
+ * @returns {boolean} 是否在白名单中
+ */
+function isWhitelisted(packageName) {
+  return WHITELIST.includes(packageName);
+}
+
+/**
+ * 格式化错误消息
+ * @param {string[]} unsupportedPackages - 不支持的包列表
+ * @returns {string} 格式化的错误消息
+ */
+function formatErrorMessage(unsupportedPackages) {
+  const lines = [
+    '',
+    '═══════════════════════════════════════',
+    '  红糖云服暂不支持以下第三方 native 组件',
+    '═══════════════════════════════════════',
+    '',
+  ];
+
+  unsupportedPackages.forEach((pkg, index) => {
+    lines.push(`  ${index + 1}. ${pkg}`);
+  });
+
+  lines.push('');
+  lines.push('═══════════════════════════════════════');
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+function trimTemplateStrings(strings, ...values) {
+  let fullString = strings.reduce((acc, str, i) => acc + str + (values[i] || ''), '');
+  return fullString.replace(/^[ \t]+/gm, '');
+}
+
+export class HtyfModulesPlugin {
+  constructor(appConfig = {}) {
+    this.config = appConfig;
+  }
+
+  apply(compiler) {
+    const config = this.config;
+
+    // 分析第三方 native 模块
+    compiler.hooks.emit.tapAsync('AnalyzeThirdPartyModulesPlugin', (compilation, callback) => {
+      try {
+        const nativeModules = new Set();
+
+        // 收集所有包含 native 代码的第三方模块
+        compilation.modules.forEach(module => {
+          if (!module.context) {
+            return;
+          }
+
+          const packageName = extractPackageName(module.context);
+          if (!packageName) {
+            return;
+          }
+
+          if (hasNativeCode(packageName)) {
+            nativeModules.add(packageName);
+          }
+        });
+
+        // 检查不支持的包
+        const unsupportedPackages = Array.from(nativeModules).filter(pkg => {
+          // 跳过白名单中的包
+          if (isWhitelisted(pkg)) {
+            return false;
+          }
+
+          // 如果不在共享配置中，则不支持
+          return !isInSharedConfig(pkg);
+        });
+
+        // 如果有不支持的包，抛出错误
+        if (unsupportedPackages.length > 0) {
+          const errorMessage = formatErrorMessage(unsupportedPackages);
+          console.error(errorMessage);
+          
+          const error = new Error(
+            `发现 ${unsupportedPackages.length} 个不支持的第三方 native 组件。\n${errorMessage}`
+          );
+          error.unsupportedPackages = unsupportedPackages;
+          callback(error);
+          return;
+        }
+
+        callback();
+      } catch (error) {
+        callback(error);
+      }
+    });
+
+    // 代码签名包装（如果启用）
+    if (config.codeSigning) {
+      compiler.hooks.emit.tapAsync('WrapCodePlugin', (compilation, callback) => {
+        try {
+          // 遍历所有编译过的资源文件
+          for (const filename in compilation.assets) {
+            if (compilation.assets.hasOwnProperty(filename)) {
+              // 获取文件内容
+              const source = compilation.assets[filename].source();
+
+              // 包裹代码
+              const wrappedSource = trimTemplateStrings`
+              ${source}
+              `;
+
+              // 更新文件内容
+              compilation.assets[filename] = {
+                source: () => wrappedSource,
+                size: () => wrappedSource.length,
+              };
+            }
+          }
+          callback();
+        } catch (error) {
+          callback(error);
+        }
+      });
+    }
+  }
+}

package/src/build.mjs

@@ -0,0 +1,146 @@
+import path from 'path';
+import fs from 'fs';
+import fse from 'fs-extra';
+import AdmZip from 'adm-zip';
+import { Logger } from './logger.mjs';
+import { CONSTANTS } from './constants.mjs';
+import { FileSystemUtils } from './file-system.mjs';
+import { CommandExecutor } from './command-executor.mjs';
+import { getMiniAppScriptId } from './utils-functions.mjs';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * 压缩文件夹为zip文件
+ * @param {string} inputPath - 输入路径
+ * @param {string} outputPath - 输出路径
+ * @returns {Promise<string>} 压缩包路径
+ */
+export async function handleZip(inputPath, outputPath) {
+  Logger.info(`开始压缩文件夹: ${inputPath}`);
+  Logger.info(`输出文件: ${outputPath}`);
+
+  if (!fs.existsSync(inputPath)) {
+    throw new Error(`输入路径不存在: ${inputPath}`);
+  }
+
+  const stats = fs.statSync(inputPath);
+  if (!stats.isDirectory()) {
+    throw new Error(`输入路径不是目录: ${inputPath}`);
+  }
+
+  const files = fs.readdirSync(inputPath);
+  Logger.debug(`目录内容: ${files.length} 个文件/文件夹`);
+
+  if (files.length === 0) {
+    Logger.warn(`警告: 目录为空，将创建空的zip文件`);
+  }
+
+  const zipPath = outputPath;
+  const admzip = new AdmZip();
+
+  try {
+    await admzip.addLocalFolderPromise(inputPath, {
+      filter: (filename) => {
+        if (filename.endsWith('.map')) {
+          Logger.debug(`过滤文件: ${filename}`);
+          return false;
+        }
+        Logger.debug(`添加文件: ${filename}`);
+        return true;
+      }
+    });
+
+    await admzip.writeZipPromise(zipPath);
+    Logger.success(`压缩完成: ${zipPath}`);
+
+    const zipStats = fs.statSync(zipPath);
+    Logger.info(`ZIP文件大小: ${FileSystemUtils.formatFileSize(zipStats.size)}`);
+
+    return zipPath;
+  } catch (error) {
+    Logger.error(`压缩失败: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * 构建小程序包
+ * @param {object} newAppInfo - 应用信息
+ * @returns {Promise<string>} 压缩包路径
+ */
+export async function mpBuildShell(newAppInfo) {
+  Logger.info(`开始构建小程序包...`);
+  Logger.info(`应用: ${newAppInfo.name}`);
+  Logger.info(`应用ID: ${newAppInfo.appid}`);
+  Logger.info(`版本: ${newAppInfo.version}`);
+  Logger.info(`平台: ${CONSTANTS.BUNDLE_PLATFORM}`);
+  
+  // 验证必需字段
+  if (!newAppInfo.name || !newAppInfo.appid || !newAppInfo.version) {
+    throw new Error('缺少必需的应用信息: name, appid, version');
+  }
+  
+  // 创建临时目录
+  const tempPath = CONSTANTS.TEMP_DIR;
+  if (!FileSystemUtils.ensureDirectory(tempPath)) {
+    throw new Error('无法创建临时目录');
+  }
+
+  const mpOutputPath = CONSTANTS.MP_OUTPUT_DIR;
+  if (!FileSystemUtils.ensureDirectory(mpOutputPath)) {
+    throw new Error('无法创建输出目录');
+  }
+
+  const version = newAppInfo.version;
+  const appid = newAppInfo.appid;
+  const scriptName = getMiniAppScriptId(appid, version);
+
+  const appJson = {
+    type: 'app',
+    engines: '2.0.0',
+    name: newAppInfo.name,
+    appid: appid,
+    version: version,
+    appUrlConfig: newAppInfo.appUrlConfig || `${newAppInfo.host}/app.json`,
+    zipUrl: newAppInfo.zipUrl || `${newAppInfo.host}/dist.dgz`
+  };
+  
+  const outputPath = path.join(mpOutputPath, './dist');
+  const rootIndexPath = path.join(tempPath, '../index.js');
+
+  const mpOptions = {
+    name: scriptName,
+    filename: `${scriptName}.bundle`,
+    exposes: {
+      'App': newAppInfo.entry,
+    },
+    outputPath: path.join(mpOutputPath, './build'),
+    extraChunksPath: outputPath,
+  };
+
+  const appJsonPath = path.join(mpOutputPath, 'app.json');
+  fs.writeFileSync(appJsonPath, JSON.stringify(appJson, undefined, 2));
+  const webpackConfigPath = path.join(__dirname, 'webpack.config.mjs');
+
+  const command = `npx cross-env APP_ROOT_INDEX_PATH=${rootIndexPath} APP_EXPOSES_OPTIONS=${encodeURI(JSON.stringify(mpOptions))} webpack --config ${webpackConfigPath}`;
+
+  try {
+    await CommandExecutor.execute(command, {
+      description: '构建小程序包',
+      timeout: 120000,
+      showCommand: false
+    });
+
+    fs.copyFileSync(appJsonPath, path.join(outputPath, `./app.json`));
+    const zipPath = await handleZip(outputPath, path.join(outputPath, `../dist.dgz`));
+    Logger.success(`压缩包已创建: ${zipPath}`);
+    return zipPath;
+  } catch (error) {
+    Logger.error(`小程序构建失败: ${error.message}`);
+    throw error;
+  }
+}
+

package/src/clean.mjs

@@ -0,0 +1,83 @@
+import path from 'path';
+import { Logger } from './logger.mjs';
+import { CONSTANTS } from './constants.mjs';
+import { FileSystemUtils } from './file-system.mjs';
+import { getProjectRoot } from './utils.mjs';
+
+const projectPath = getProjectRoot();
+
+/**
+ * 清理临时文件
+ * @param {string} cleanType - 清理类型 ('all', 'build', 'temp', 'logs', 'cache', 或应用名称)
+ */
+export async function cleanShell(cleanType = 'all') {
+  Logger.info('开始清理文件...');
+
+  const pathsToClean = [];
+  let totalSizeBefore = 0;
+
+  if (cleanType === 'build') {
+    // 只清理构建输出
+    const buildPath = CONSTANTS.MP_OUTPUT_DIR;
+    pathsToClean.push(buildPath);
+    totalSizeBefore += FileSystemUtils.calculateDirectorySize(buildPath);
+    Logger.info('清理构建输出文件...');
+  } else if (cleanType === 'temp') {
+    // 只清理临时文件
+    const tempPath = CONSTANTS.TEMP_DIR;
+    pathsToClean.push(tempPath);
+    totalSizeBefore += FileSystemUtils.calculateDirectorySize(tempPath);
+    Logger.info('清理临时文件...');
+  } else if (cleanType === 'logs') {
+    // 清理日志文件
+    const logsPath = CONSTANTS.LOGS_DIR;
+    pathsToClean.push(logsPath);
+    totalSizeBefore += FileSystemUtils.calculateDirectorySize(logsPath);
+    Logger.info('清理日志文件...');
+  } else if (cleanType === 'cache') {
+    // 清理缓存文件
+    const cachePaths = [
+      path.join(projectPath, 'node_modules/.cache'),
+      path.join(projectPath, '.cache'),
+      path.join(projectPath, 'dist/.cache')
+    ];
+    pathsToClean.push(...cachePaths);
+    cachePaths.forEach(cachePath => {
+      totalSizeBefore += FileSystemUtils.calculateDirectorySize(cachePath);
+    });
+    Logger.info('清理缓存文件...');
+  } else if (cleanType && cleanType !== 'all') {
+    // 清理指定应用的文件
+    const appTempPath = path.join(CONSTANTS.TEMP_DIR, cleanType);
+    const appBuildPath = path.join(CONSTANTS.MP_OUTPUT_DIR, cleanType);
+    pathsToClean.push(appTempPath, appBuildPath);
+    totalSizeBefore += FileSystemUtils.calculateDirectorySize(appTempPath) + FileSystemUtils.calculateDirectorySize(appBuildPath);
+    Logger.info(`清理应用 ${cleanType} 的文件...`);
+  } else {
+    // 清理所有文件
+    const allPaths = [
+      path.join(CONSTANTS.TEMP_DIR),
+      path.join(CONSTANTS.MP_OUTPUT_DIR),
+      path.join(CONSTANTS.LOGS_DIR),
+      path.join(projectPath, 'node_modules/.cache'),
+      path.join(projectPath, '.cache'),
+      path.join(projectPath, 'dist/.cache')
+    ];
+    pathsToClean.push(...allPaths);
+    allPaths.forEach(cleanPath => {
+      totalSizeBefore += FileSystemUtils.calculateDirectorySize(cleanPath);
+    });
+    Logger.info('清理所有临时文件...');
+  }
+
+  let cleanedCount = 0;
+  for (const cleanPath of pathsToClean) {
+    if (FileSystemUtils.cleanDirectory(cleanPath)) {
+      cleanedCount++;
+    }
+  }
+
+  const freedSpace = FileSystemUtils.formatFileSize(totalSizeBefore);
+  Logger.success(`清理完成，已清理 ${cleanedCount} 个目录，释放空间: ${freedSpace}`);
+}
+

package/src/command-executor.mjs

@@ -0,0 +1,133 @@
+import shell from 'shelljs';
+import ora from 'ora';
+import { Logger } from './logger.mjs';
+import { CONSTANTS } from './constants.mjs';
+
+/**
+ * 命令执行工具类
+ */
+export class CommandExecutor {
+  static async execute(command, options = {}) {
+    const {
+      silent = false,
+      fatal = true,
+      timeout = CONSTANTS.DEFAULT_TIMEOUT,
+      retryCount = CONSTANTS.MAX_RETRY_COUNT,
+      description = '执行命令',
+      showCommand = false
+    } = options;
+
+    const displayCommand = showCommand ? command : description;
+    const spinner = ora(displayCommand).start();
+
+    // 信号处理：当收到退出信号时，停止 spinner
+    const cleanup = () => {
+      spinner.stop();
+    };
+    process.once('SIGINT', cleanup);
+    process.once('SIGTERM', cleanup);
+
+    try {
+      for (let attempt = 1; attempt <= retryCount; attempt++) {
+        try {
+          Logger.debug(`执行命令 (尝试 ${attempt}/${retryCount}): ${command}`);
+
+          const result = await new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+              reject(new Error(`命令执行超时 (${timeout}ms)`));
+            }, timeout);
+
+            shell.exec(command, {
+              silent: silent,
+              fatal: false,
+              async: false
+            }, (code, stdout, stderr) => {
+              clearTimeout(timeoutId);
+              resolve({ code, stdout, stderr });
+            });
+          });
+
+          if (result.code === 0) {
+            process.removeListener('SIGINT', cleanup);
+            process.removeListener('SIGTERM', cleanup);
+            spinner.succeed(`${description} 成功`);
+            Logger.debug(`命令输出: ${result.stdout}`);
+            return result;
+          } else {
+            throw new Error(`命令执行失败，退出码: ${result.code}, 错误: ${result.stderr}`);
+          }
+        } catch (error) {
+          // 如果是用户中断，直接退出
+          if (error.message && (error.message.includes('SIGINT') || error.message.includes('SIGTERM'))) {
+            process.removeListener('SIGINT', cleanup);
+            process.removeListener('SIGTERM', cleanup);
+            spinner.stop();
+            throw error;
+          }
+
+          if (attempt === retryCount) {
+            process.removeListener('SIGINT', cleanup);
+            process.removeListener('SIGTERM', cleanup);
+            spinner.fail(`${description} 失败 (${retryCount} 次尝试后)`);
+            Logger.error(`命令执行失败: ${error.message}`);
+
+            if (fatal) {
+              process.exit(1);
+            }
+            throw error;
+          } else {
+            Logger.warn(`命令执行失败，准备重试 (${attempt}/${retryCount}): ${error.message}`);
+            await new Promise(resolve => setTimeout(resolve, 1000 * attempt)); // 递增延迟
+          }
+        }
+      }
+    } catch (error) {
+      process.removeListener('SIGINT', cleanup);
+      process.removeListener('SIGTERM', cleanup);
+      spinner.stop();
+      throw error;
+    }
+  }
+
+  static async executeWithProgress(command, options = {}) {
+    const { description = '执行命令', progressCallback } = options;
+
+    return new Promise((resolve, reject) => {
+      const child = shell.exec(command, {
+        silent: false,
+        fatal: false,
+        async: true
+      });
+
+      let output = '';
+
+      child.stdout?.on('data', (data) => {
+        output += data;
+        if (progressCallback) {
+          progressCallback(data.toString());
+        }
+      });
+
+      child.stderr?.on('data', (data) => {
+        output += data;
+        Logger.warn(`命令输出: ${data}`);
+      });
+
+      child.on('close', (code) => {
+        if (code === 0) {
+          Logger.success(`${description} 完成`);
+          resolve({ code, output });
+        } else {
+          Logger.error(`${description} 失败，退出码: ${code}`);
+          reject(new Error(`命令执行失败，退出码: ${code}`));
+        }
+      });
+
+      child.on('error', (error) => {
+        Logger.error(`${description} 出错: ${error.message}`);
+        reject(error);
+      });
+    });
+  }
+}
+

package/src/config.mjs

@@ -0,0 +1,52 @@
+import md5 from 'md5';
+import { v4 as uuidv4 } from 'uuid';
+import { CONSTANTS } from './constants.mjs';
+
+/**
+ * 项目初始化配置类
+ */
+export class ProjectConfig {
+  constructor() {
+    this.validators = {
+      appName: /^([a-z]+)(-[a-z0-9]+)*$/,
+      displayName: /^[\u4e00-\u9fa5a-zA-Z0-9]{2,4}$/
+    };
+
+    this.templates = {
+      [CONSTANTS.TEMPLATE_TYPES.APP_TEMPLATE]: {
+        name: 'app-template',
+        tempPath: '_apps_temp_'
+      },
+      [CONSTANTS.TEMPLATE_TYPES.GAME_TEMPLATE]: {
+        name: 'game-template',
+        tempPath: '_games_temp_'
+      }
+    };
+  }
+
+  validateAppName(name) {
+    return this.validators.appName.test(name);
+  }
+
+  validateDisplayName(name) {
+    return this.validators.displayName.test(name);
+  }
+
+  generateAppId() {
+    return md5(uuidv4({
+      random: [0x10, 0x91, 0x56, 0xbe, 0xc4, 0xfb, 0xc1, 0xea, 0x71, 0xb4, 0xef, 0xe1, 0x67, 0x1c, 0x58, 0x36]
+    }));
+  }
+
+  createProjectConfig(appName, displayName, appid) {
+    return {
+      type: 'app',
+      name: appName,
+      projectname: displayName,
+      appid: appid,
+      appUrlConfig: 'https://xxx.cos.ap-chengdu.myqcloud.com/assets/testMiniApps/htyanimation/app.json',
+      zipUrl: 'https://xxxxx.myqcloud.com/assets/testMiniApps/xxxxx/outputs/dist.dgz'
+    };
+  }
+}
+