@htyf-mp/cli 0.1.3 → 0.2.0-beta.1

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@htyf-mp/cli",
-  "version": "0.1.3",
+  "version": "0.2.0-beta.1",
   "description": "红糖云服app小程序模板-cli",
   "type": "module",
-  "bin": "cli.js",
+  "bin": "src/index.mjs",
   "scripts": {
+    "start": "node src/index.mjs",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "keywords": [
@@ -20,14 +21,30 @@
     "url": "https://github.com/htyf-mp-community/htyf-mp.git"
   },
   "dependencies": {
+    "@callstack/repack": "^5.1.3",
+    "@callstack/repack-plugin-expo-modules": "^5.1.3",
+    "@callstack/repack-plugin-reanimated": "^5.1.3",
     "@inquirer/prompts": "^3.1.1",
-    "chalk": "^5.3.0",
+    "adm-zip": "0.5.10",
+    "boxen": "^8.0.1",
+    "chalk": "^5.4.1",
     "cli-spinners": "^2.9.0",
     "commander": "^11.0.0",
+    "cross-env": "^7.0.3",
     "execa": "^8.0.1",
-    "fs-extra": "^11.2.0",
+    "fs-extra": "^11.3.0",
+    "gradient-string": "^3.0.0",
+    "inquirer": "^12.8.2",
+    "lodash": "^4.17.21",
     "md5": "^2.3.0",
     "ora": "^7.0.1",
-    "uuid": "^9.0.1"
+    "portfinder": "^1.0.37",
+    "qrcode": "^1.5.4",
+    "shelljs": "^0.10.0",
+    "superstatic": "^9.2.0",
+    "systeminformation": "^5.27.7",
+    "terser-webpack-plugin": "^5.3.14",
+    "uuid": "^9.0.1",
+    "webpack": "^5.100.2"
   }
 }

package/src/ListImportsPlugin.mjs

@@ -0,0 +1,98 @@
+
+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'))
+
+function trimTemplateStrings(strings, ...values) {
+  let fullString = strings.reduce((acc, str, i) => acc + str + (values[i] || ''), '');
+  return fullString.replace(/^[ \t]+/gm, '');
+}
+
+export class AnalyzeThirdPartyModulesPlugin {
+  constructor(appConfig) {
+    this.config = appConfig;
+  }
+  apply(compiler) {
+    const config = this.config;
+    compiler.hooks.emit.tapAsync('AnalyzeThirdPartyModulesPlugin', (compilation, callback) => {
+      let thirdPartyModules = new Set();
+
+      compilation.modules.forEach(module => {
+        if (module.context && module.context.includes('node_modules')) {
+          let packageName = module.context.split('node_modules/')[1].split('/')[0];
+          if (packageName.startsWith('@')) {
+            packageName = module.context.split('node_modules/')[1].split('/').splice(0,2).join('/');
+          }
+          const ios_path = path.join(__dirname, '../node_modules/', packageName, 'ios');
+          const and_path = path.join(__dirname, '../node_modules/', packageName, 'android');
+          const isNative = fse.pathExistsSync(ios_path) || fse.pathExistsSync(and_path);
+          if (isNative) {
+            thirdPartyModules.add(packageName);
+          }
+        }
+      });
+      const nonsupport = []
+      thirdPartyModules = Array.from(thirdPartyModules);
+      for (const key in thirdPartyModules) {
+        const pkg = thirdPartyModules[key];
+        if (!sharedPkg[pkg]) {
+          if (
+            pkg !== 'expo-splash-screen' &&
+            pkg !== '@callstack/repack' &&
+            pkg !== 'react-native-iap'
+          ) {
+            nonsupport.push(pkg)
+          }
+        }
+      }
+      if (nonsupport.length) {
+        const msgArr = ['红糖云服暂不支持以上第三方native组件']
+        console.log(' ')
+        console.log('xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')
+        console.log('xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')
+        console.log(' ')
+        console.log('红糖云服暂不支持以下第三方native组件: ')
+        for (const key in nonsupport) {
+          const element = nonsupport[key];
+          const _msg = `${Number(key) + 1}. ${element}`;
+          console.log(_msg)
+          msgArr.push(_msg)
+        }
+        console.log(' ')
+        console.log('xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')
+        console.log('xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')
+        console.log(' ')
+        console.log(' ')
+        callback(msgArr.join(`\n`));
+      } else {
+        callback();
+      }
+    });
+    if (config.codeSigning) {
+      compiler.hooks.emit.tapAsync('WrapCodePlugin', (compilation, callback) => {
+        // 遍历所有编译过的资源文件
+        for (const filename in compilation.assets) {
+          if (compilation.assets.hasOwnProperty(filename)) {
+            // 获取文件内容
+            let source = compilation.assets[filename].source();
+
+            // 包裹代码
+            const wrappedSource = trimTemplateStrings`
+              ${source}
+            `;
+
+            // 更新文件内容
+            compilation.assets[filename] = {
+              source: () => wrappedSource,
+              size: () => wrappedSource.length
+            };
+          }
+        }
+        callback();
+      });
+    }
+  }
+}

package/src/index.mjs

@@ -0,0 +1,825 @@
+#!/usr/bin/env node
+
+/**
+ * React Native 应用 CLI 工具
+ * 用于管理多应用项目的开发、构建和部署
+ *
+ * @author CLI Team
+ * @version 2.0.0
+ */
+
+import inquirer from 'inquirer';
+import shell from 'shelljs';
+import fs from 'fs';
+import { fileURLToPath } from 'node:url';
+import path from 'path';
+import lodash from 'lodash';
+import fse from 'fs-extra';
+import superstatic from 'superstatic';
+import AdmZip from 'adm-zip';
+import QRCode from 'qrcode';
+import portfinder from 'portfinder';
+import si from 'systeminformation';
+import chalk from 'chalk';
+import ora from 'ora';
+import boxen from 'boxen';
+import gradient from 'gradient-string';
+
+// 获取当前文件的绝对路径和目录
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const projectPath = path.resolve(__dirname, '../../../../');
+
+// 常量定义
+const CONSTANTS = {
+  SRC_DIR: '../src',
+  TEMP_DIR: './.temp',
+  MP_OUTPUT_DIR: './.mp-output',
+  LOGS_DIR: './.logs',
+  DEFAULT_VERSION_NAME: '1.0.0',
+  DEFAULT_VERSION_CODE: '1',
+  VERSION_NAME_REGEX: /^\d+(\.\d+){2}$/g,
+  VERSION_CODE_REGEX: /^\d+$/g,
+  WEBPACK_PORT: 8081,
+  BUNDLE_ENTRY_FILE: 'index.js',
+  BUNDLE_PLATFORM: 'ios',
+  MAX_RETRY_COUNT: 3,
+  DEFAULT_TIMEOUT: 30000
+};
+
+// 操作类型枚举
+const ACTION_TYPES = {
+  START: 'start',
+  MP_BUILD: 'mp-build',
+  MP_DEBUG: 'mp-debug',
+  CLEAN: 'clean',
+  QUIT: 'quit'
+};
+
+// 日志级别枚举
+const LOG_LEVELS = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3
+};
+
+// 当前日志级别
+let currentLogLevel = LOG_LEVELS.INFO;
+
+/**
+ * 日志工具类
+ */
+class Logger {
+  static debug(message, ...args) {
+    if (currentLogLevel <= LOG_LEVELS.DEBUG) {
+      console.log(chalk.gray(`[DEBUG] ${message}`), ...args);
+    }
+  }
+
+  static info(message, ...args) {
+    if (currentLogLevel <= LOG_LEVELS.INFO) {
+      console.log(chalk.blue(`[INFO] ${message}`), ...args);
+    }
+  }
+
+  static warn(message, ...args) {
+    if (currentLogLevel <= LOG_LEVELS.WARN) {
+      console.log(chalk.yellow(`[WARN] ${message}`), ...args);
+    }
+  }
+
+  static error(message, ...args) {
+    if (currentLogLevel <= LOG_LEVELS.ERROR) {
+      console.log(chalk.red(`[ERROR] ${message}`), ...args);
+    }
+  }
+
+  static success(message, ...args) {
+    console.log(chalk.green(`[SUCCESS] ${message}`), ...args);
+  }
+
+  static writeToFile(message, level = 'INFO') {
+    const logDir = path.join(__dirname, CONSTANTS.LOGS_DIR);
+    const logFile = path.join(logDir, `cli-${new Date().toISOString().split('T')[0]}.log`);
+
+    try {
+      fse.ensureDirSync(logDir);
+      const timestamp = new Date().toISOString();
+      const logEntry = `[${timestamp}] [${level}] ${message}\n`;
+      fs.appendFileSync(logFile, logEntry);
+    } catch (error) {
+      console.error('写入日志文件失败:', error.message);
+    }
+  }
+}
+
+/**
+ * 配置验证工具类
+ */
+class ConfigValidator {
+  static validateAppConfig(config) {
+    const errors = [];
+    const warnings = [];
+
+    // 必需字段检查
+    const requiredFields = ['productName', 'versionName', 'versionCode'];
+    requiredFields.forEach(field => {
+      if (!config[field]) {
+        errors.push(`缺少必需字段: ${field}`);
+      }
+    });
+
+    // 版本格式检查
+    // if (config.versionName && !CONSTANTS.VERSION_NAME_REGEX.test(`${config.versionName}`)) {
+    //   errors.push(`版本名称格式错误: ${config.versionName}，应为 x.y.z 格式`);
+    // }
+    // if (config.versionCode && !CONSTANTS.VERSION_CODE_REGEX.test(`${config.versionCode}`)) {
+    //   errors.push(`版本代码格式错误: ${config.versionCode}，应为数字格式`);
+    // }
+
+    // 平台配置检查
+    if (config.iosBuild) {
+      if (!config.iosBuild.appId) {
+        warnings.push('iOS配置缺少appId');
+      }
+    }
+
+    if (config.andBuild) {
+      if (!config.andBuild.appId) {
+        warnings.push('Android配置缺少appId');
+      }
+    }
+
+    return { errors, warnings, isValid: errors.length === 0 };
+  }
+
+  static validateNetworkConfig() {
+    return new Promise(async (resolve) => {
+      try {
+        const networkInfo = await si.networkInterfaces();
+        const defaultNet = (lodash.isArray(networkInfo) ? networkInfo : [networkInfo])
+          .find(i => lodash.get(i, 'default', false));
+
+        if (!defaultNet || !defaultNet.ip4) {
+          resolve({ isValid: false, error: '无法获取网络配置' });
+          return;
+        }
+
+        resolve({
+          isValid: true,
+          host: defaultNet.ip4,
+          interface: defaultNet.iface
+        });
+      } catch (error) {
+        resolve({ isValid: false, error: error.message });
+      }
+    });
+  }
+}
+
+/**
+ * 文件系统工具类
+ */
+class FileSystemUtils {
+  static ensureDirectory(dirPath) {
+    try {
+      fse.ensureDirSync(dirPath);
+      Logger.debug(`目录已确保存在: ${dirPath}`);
+      return true;
+    } catch (error) {
+      Logger.error(`创建目录失败: ${dirPath}`, error.message);
+      return false;
+    }
+  }
+
+  static cleanDirectory(dirPath) {
+    try {
+      if (fs.existsSync(dirPath)) {
+        fse.removeSync(dirPath);
+        Logger.info(`目录已清理: ${dirPath}`);
+      }
+      return true;
+    } catch (error) {
+      Logger.error(`清理目录失败: ${dirPath}`, error.message);
+      return false;
+    }
+  }
+
+  static backupFile(filePath) {
+    try {
+      if (fs.existsSync(filePath)) {
+        const backupPath = `${filePath}.backup.${Date.now()}`;
+        fse.copySync(filePath, backupPath);
+        Logger.info(`文件已备份: ${backupPath}`);
+        return backupPath;
+      }
+      return null;
+    } catch (error) {
+      Logger.error(`备份文件失败: ${filePath}`, error.message);
+      return null;
+    }
+  }
+
+  static getFileSize(filePath) {
+    try {
+      const stats = fs.statSync(filePath);
+      return stats.size;
+    } catch (error) {
+      return 0;
+    }
+  }
+
+  static formatFileSize(bytes) {
+    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+    if (bytes === 0) return '0 Bytes';
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    return Math.round(bytes / Math.pow(1024, i) * 100) / 100 + ' ' + sizes[i];
+  }
+}
+
+/**
+ * 命令执行工具类
+ */
+class CommandExecutor {
+  static async execute(command, options = {}) {
+    const {
+      silent = false,
+      fatal = true,
+      timeout = CONSTANTS.DEFAULT_TIMEOUT,
+      retryCount = CONSTANTS.MAX_RETRY_COUNT,
+      description = '执行命令'
+    } = options;
+
+    const spinner = ora(`${description}: ${command}`).start();
+
+    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) {
+          spinner.succeed(`${description} 成功`);
+          Logger.debug(`命令输出: ${result.stdout}`);
+          return result;
+        } else {
+          throw new Error(`命令执行失败，退出码: ${result.code}, 错误: ${result.stderr}`);
+        }
+      } catch (error) {
+        if (attempt === retryCount) {
+          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)); // 递增延迟
+        }
+      }
+    }
+  }
+
+  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);
+      });
+    });
+  }
+}
+
+/**
+ * 验证版本号格式
+ *
+ * @param {string} versionName - 版本名称 (格式: x.y.z)
+ * @param {string} versionCode - 版本代码 (格式: 数字)
+ * @returns {boolean} 验证结果
+ */
+function validateVersion(versionName, versionCode) {
+  const isVersionNameValid = CONSTANTS.VERSION_NAME_REGEX.test(versionName);
+  const isVersionCodeValid = CONSTANTS.VERSION_CODE_REGEX.test(versionCode);
+
+  if (!isVersionNameValid) {
+    Logger.error(`版本名称格式错误: ${versionName}，应为 x.y.z 格式`);
+  }
+
+  if (!isVersionCodeValid) {
+    Logger.error(`版本代码格式错误: ${versionCode}，应为数字格式`);
+  }
+
+  return isVersionNameValid && isVersionCodeValid;
+}
+
+/**
+ * 更新应用配置
+ *
+ * @param {string} appName - 应用名称
+ * @param {Object} newConfig - 新配置
+ * @returns {boolean} 更新是否成功
+ */
+function updateAppConfig(newConfig) {
+  try {
+    const configPath = path.join(projectPath, 'app.json');
+    const localConfig = fse.readJsonSync(configPath);
+    const _newConfig = {
+      ...localConfig,
+      'htyf': {
+        ...localConfig.htyf,
+        ...newConfig
+      }
+    }
+    // 备份原配置文件
+    // FileSystemUtils.backupFile(configPath);
+
+    // 写入新配置
+    fs.writeFileSync(configPath, JSON.stringify(_newConfig, undefined, 2), 'utf-8');
+    Logger.success(`配置文件已更新: ${configPath}`);
+
+    return true;
+  } catch (error) {
+    Logger.error(`更新配置文件失败: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * 构建小程序包
+ *
+ * @param {string} appName - 应用名称
+ */
+async function mpBuildShell(newAppInfo) {
+  Logger.info(`开始构建小程序包...`);
+  Logger.info(`应用: ${newAppInfo.name}`);
+  Logger.info(`平台: ${CONSTANTS.BUNDLE_PLATFORM}`);
+
+  // 创建临时目录
+  const tempPath = path.join(__dirname, CONSTANTS.TEMP_DIR, newAppInfo.name);
+  if (!FileSystemUtils.ensureDirectory(tempPath)) {
+    return;
+  }
+
+  const mpOutputPath = path.join(__dirname, CONSTANTS.MP_OUTPUT_DIR, newAppInfo.name, 'dist');
+  if (!FileSystemUtils.ensureDirectory(mpOutputPath)) {
+    return;
+  }
+  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 mpOptions = {
+    name: scriptName,
+    filename: `${scriptName}.bundle`,
+    exposes: {
+      'App': `./src/${newAppInfo.name}/index.tsx`,
+    },
+    outputPath: path.join(mpOutputPath, '../build'),
+    extraChunksPath: path.join(mpOutputPath),
+  }
+
+
+  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_USE_ENTRY_DEV=${newAppInfo.name} APP_EXPOSES_OPTIONS=${encodeURI(JSON.stringify(mpOptions))} APP_EXPOSES_FILENAME=${mpOptions.filename} APP_EXPOSES_EXPOSES=${JSON.stringify(mpOptions.exposes)} npx webpack --config ${webpackConfigPath}`;
+
+  try {
+    await CommandExecutor.execute(command, {
+      description: '构建小程序包',
+      timeout: 120000
+    });
+
+    fs.copyFileSync(appJsonPath, path.join(mpOutputPath, '../dist', `./app.json`));
+    const zipPath = await handleZip(mpOutputPath, path.join(mpOutputPath, '../', `./dist.dgz`));
+    Logger.success(`压缩包已创建: ${zipPath}`);
+    return zipPath;
+  } catch (error) {
+    Logger.error(`小程序构建失败: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * 压缩文件夹为zip文件
+ *
+ * @param {string} inputPath - 输入文件夹路径
+ * @param {string} outputPath - 输出zip文件路径
+ * @returns {Promise<string>} zip文件路径
+ */
+const handleZip = async (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} 个文件/文件夹`);
+  files.forEach(file => {
+    const filePath = path.join(inputPath, file);
+    const fileStats = fs.statSync(filePath);
+    Logger.debug(`  - ${file} (${fileStats.isDirectory() ? '目录' : '文件'})`);
+  });
+
+  if (files.length === 0) {
+    Logger.warn(`警告: 目录为空，将创建空的zip文件`);
+  }
+
+  const zipPath = outputPath;
+  const admzip = new AdmZip();
+
+  try {
+    await admzip.addLocalFolderPromise(inputPath, {
+      filter: (filename) => {
+        // 过滤掉 .map 文件
+        if (filename.endsWith('.map')) {
+          Logger.debug(`过滤文件: ${filename}`);
+          return false;
+        }
+        Logger.debug(`添加文件: ${filename}`);
+        return true;
+      }
+    });
+
+    await admzip.writeZipPromise(zipPath);
+    Logger.success(`压缩完成: ${zipPath}`);
+
+    // 检查生成的zip文件大小
+    const zipStats = fs.statSync(zipPath);
+    Logger.info(`ZIP文件大小: ${FileSystemUtils.formatFileSize(zipStats.size)}`);
+
+    return zipPath;
+  } catch (error) {
+    Logger.error(`压缩失败: ${error.message}`);
+    throw error;
+  }
+};
+
+/**
+ * 小程序真机调试
+ *
+ * @param {string} appName - 应用名称
+ */
+async function mpDebugShell(newAppInfo) {
+  try {
+    const zipPath = await mpBuildShell(newAppInfo);
+    const assetsPath = path.dirname(zipPath);
+    const appJsonPath = path.join(assetsPath, 'app.json');
+
+    Logger.info(`资源路径: ${assetsPath}`);
+    const applocaljson = fse.readJsonSync(appJsonPath);
+
+    // 验证网络配置
+    const networkValidation = await ConfigValidator.validateNetworkConfig();
+    if (!networkValidation.isValid) {
+      throw new Error(`网络配置验证失败: ${networkValidation.error}`);
+    }
+
+    const host = networkValidation.host;
+    const port = await portfinder.getPortPromise();
+
+    const app = superstatic.server({
+      port: port,
+      address: host,
+      cwd: assetsPath
+    });
+
+    const server = app.listen(function () {
+      const address = server.address();
+
+      const debugerAppUrlConfig = `http://${host}:${address.port}/app.json`;
+      const debugerZip = `http://${host}:${address.port}/dist.dgz`;
+      const args = {
+        ...applocaljson,
+        development: true,
+        "name": applocaljson.name,
+        "appid": applocaljson.appid,
+        "version": applocaljson.version,
+        appUrlConfig: debugerAppUrlConfig,
+        zipUrl: debugerZip,
+      }
+
+      fse.writeJSONSync(appJsonPath, {
+        ...fse.readJSONSync(appJsonPath),
+        appUrlConfig: debugerAppUrlConfig,
+        zipUrl: debugerZip,
+      });
+
+      const qrcodeUrl = `https://share.dagouzhi.com/#/pages/index/index?data=${encodeURIComponent(JSON.stringify(args))}`;
+
+      // 显示调试信息
+      console.log('\n');
+      console.log(boxen(
+        gradient.rainbow('小程序真机调试') + '\n\n' +
+        chalk.cyan('服务器地址: ') + chalk.white(`${host}:${address.port}`) + '\n' +
+        chalk.cyan('应用名称: ') + chalk.white(applocaljson.name) + '\n' +
+        chalk.cyan('应用ID: ') + chalk.white(applocaljson.appid) + '\n' +
+        chalk.cyan('版本: ') + chalk.white(applocaljson.version),
+        {
+          padding: 1,
+          margin: 1,
+          borderStyle: 'round',
+          borderColor: 'cyan'
+        }
+      ));
+
+      console.log('\n' + chalk.yellow('调试配置:'));
+      console.log(JSON.stringify(args, undefined, 2));
+
+      console.log('\n' + chalk.green('调试链接:'));
+      console.log(qrcodeUrl);
+
+      console.log('\n' + chalk.blue('二维码:'));
+      printQrcode(qrcodeUrl);
+
+      Logger.info('调试服务器已启动，按 Ctrl+C 停止');
+    });
+
+    // 优雅关闭
+    process.on('SIGINT', () => {
+      Logger.info('正在关闭调试服务器...');
+      server.close(() => {
+        Logger.success('调试服务器已关闭');
+        process.exit(0);
+      });
+    });
+
+  } catch (error) {
+    Logger.error(`小程序调试失败: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * 清理临时文件
+ *
+ * @param {string} appName - 应用名称（可选）
+ */
+async function cleanShell(appName = null) {
+  Logger.info('开始清理临时文件...');
+
+  const pathsToClean = [];
+
+  if (appName) {
+    // 清理指定应用的临时文件
+    pathsToClean.push(
+      path.join(__dirname, CONSTANTS.TEMP_DIR, appName),
+      path.join(__dirname, CONSTANTS.MP_OUTPUT_DIR, appName)
+    );
+  } else {
+    // 清理所有临时文件
+    pathsToClean.push(
+      path.join(__dirname, CONSTANTS.TEMP_DIR),
+      path.join(__dirname, CONSTANTS.MP_OUTPUT_DIR)
+    );
+  }
+
+  let cleanedCount = 0;
+  for (const path of pathsToClean) {
+    if (FileSystemUtils.cleanDirectory(path)) {
+      cleanedCount++;
+    }
+  }
+
+  Logger.success(`清理完成，已清理 ${cleanedCount} 个目录`);
+}
+
+/**
+ * 打印二维码
+ *
+ * @param {string} url - 要生成二维码的URL
+ */
+const printQrcode = async (url) => {
+  try {
+    let terminalStr = await QRCode.toString(url, { type: 'terminal', small: true });
+    console.log(terminalStr);
+  } catch (error) {
+    Logger.error(`生成二维码失败: ${error.message}`);
+  }
+};
+
+/**
+ * 主启动函数
+ * 处理用户选择的操作类型
+ *
+ * @param {string} action - 操作类型
+ */
+async function Start(action) {
+  const actionNames = {
+    [ACTION_TYPES.MP_BUILD]: '小程序构建',
+    [ACTION_TYPES.MP_DEBUG]: '小程序调试',
+    [ACTION_TYPES.CLEAN]: '清理模式',
+    [ACTION_TYPES.QUIT]: '退出'
+  };
+
+  Logger.info(`当前操作: ${actionNames[action] || '未知操作'}`);
+
+  // 如果是退出操作，直接返回
+  if (action === ACTION_TYPES.QUIT) {
+    Logger.info('再见!');
+    return;
+  }
+
+  // 如果是清理或状态操作，不需要选择应用
+  if (action === ACTION_TYPES.CLEAN) {
+    const { cleanAll } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'cleanAll',
+        message: '是否清理所有应用的临时文件？',
+        default: false
+      }
+    ]);
+
+    if (cleanAll) {
+      await cleanShell();
+    }
+    return;
+  }
+
+
+  // 显示应用选择界面
+  try {
+    const appInfo = fse.readJsonSync(path.join(projectPath, 'app.json')).htyf;
+    if (!appInfo) {
+      Logger.error('应用配置不存在，请先在app.json中配置htyf');
+      return;
+    }
+    const { versionName } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'versionName',
+        message: '请输入应用版本名称 (格式: x.y.z):',
+        default: appInfo?.version,
+        validate: (input) => {
+          return CONSTANTS.VERSION_NAME_REGEX.test(input) || '请输入正确的版本名称格式 (x.y.z)';
+        }
+      },
+    ]);
+
+    Logger.info(`用户选择:`);
+    Logger.info(`版本名称: ${versionName}`);
+
+    // 验证版本格式
+    // if (!validateVersion(versionName, versionCode)) {
+    //   return;
+    // }
+
+    // 合并新配置
+    const newAppInfo = lodash.merge({}, appInfo, {
+      version: versionName,
+    });
+
+    // 更新配置文件
+    if (!updateAppConfig(newAppInfo)) {
+      return;
+    }
+
+    // 显示操作信息
+    console.log('\n' + boxen(
+      chalk.cyan('应用信息') + '\n\n' +
+      chalk.white('名称: ') + chalk.yellow(`${newAppInfo.name})`) + '\n' +
+      {
+        padding: 1,
+        margin: 1,
+        borderStyle: 'round',
+        borderColor: 'yellow'
+      }
+    ));
+
+    // 执行初始化
+    Logger.info('执行初始化...');
+
+    // 根据操作类型执行相应命令
+    switch (action) {
+      case ACTION_TYPES.MP_BUILD:
+        await mpBuildShell(newAppInfo);
+        break;
+      case ACTION_TYPES.MP_DEBUG:
+        await mpDebugShell(newAppInfo);
+        break;
+      default:
+        Logger.error(`未知的操作类型: ${action}`);
+    }
+
+  } catch (error) {
+    Logger.error(`操作失败: ${error.message}`);
+    Logger.error(`错误详情: ${error.stack}`);
+  }
+}
+
+// 主程序入口
+console.log('\n' + boxen(
+  gradient.rainbow('🎯 红糖云服 应用 CLI 工具 v2.0.0') + '\n' +
+  chalk.gray('用于管理多应用项目的开发、构建和部署'),
+  {
+    padding: 1,
+    margin: 1,
+    borderStyle: 'round',
+    borderColor: 'cyan'
+  }
+));
+
+// 设置日志级别
+if (process.argv.includes('--debug')) {
+  currentLogLevel = LOG_LEVELS.DEBUG;
+  Logger.debug('调试模式已启用');
+}
+
+// 记录启动日志
+Logger.writeToFile('CLI 工具启动', 'INFO');
+
+inquirer
+  .prompt([
+    {
+      type: 'rawlist',
+      name: 'index',
+      message: '请选择你想要执行的操作：',
+      choices: [
+        { name: '🔍 小程序 - 打包小程序', value: ACTION_TYPES.MP_BUILD },
+        { name: '📦 小程序 - 真机调试', value: ACTION_TYPES.MP_DEBUG },
+        { name: '🧹 清理模式 - 清理临时文件', value: ACTION_TYPES.CLEAN },
+        { name: '👋 退出', value: ACTION_TYPES.QUIT },
+      ],
+    },
+  ])
+  .then(({ index }) => {
+    Start(index);
+  })
+  .catch((error) => {
+    Logger.error(`程序启动失败: ${error.message}`);
+    process.exit(1);
+  });
+
+export const getMiniAppScriptId = (appid, version) => {
+  return `${appid}_v${version?.replace(/\./gi, '_')}`
+}

package/src/shared-output.json

@@ -0,0 +1,82 @@
+{
+  "@bam.tech/react-native-image-resizer": "3.0.11",
+  "@dr.pogodin/react-native-fs": "2.34.0",
+  "@dr.pogodin/react-native-static-server": "0.22.0",
+  "@react-native-async-storage/async-storage": "2.2.0",
+  "@react-native-camera-roll/camera-roll": "7.10.1",
+  "@react-native-clipboard/clipboard": "1.16.3",
+  "@react-native-community/blur": "4.4.1",
+  "@react-native-community/checkbox": "0.5.20",
+  "@react-native-community/datetimepicker": "8.4.2",
+  "@react-native-community/geolocation": "3.4.0",
+  "@react-native-community/netinfo": "11.4.1",
+  "@react-native-community/slider": "4.5.7",
+  "@react-native-cookies/cookies": "6.2.1",
+  "@react-native-documents/picker": "10.1.5",
+  "@react-native-masked-view/masked-view": "0.3.2",
+  "@react-native-picker/picker": "2.11.1",
+  "@react-native-segmented-control/segmented-control": "2.5.7",
+  "@sayem314/react-native-keep-awake": "1.3.1",
+  "@shopify/flash-list": "1.8.3",
+  "@shopify/react-native-skia": "2.1.1",
+  "expo": "53.0.20",
+  "expo-asset": "11.1.7",
+  "expo-audio": "0.4.8",
+  "expo-brightness": "13.1.4",
+  "expo-camera": "16.1.11",
+  "expo-clipboard": "7.1.5",
+  "expo-constants": "17.1.7",
+  "expo-crypto": "14.1.5",
+  "expo-font": "13.3.2",
+  "expo-image": "2.4.0",
+  "expo-linking": "7.1.7",
+  "expo-router": "5.1.4",
+  "expo-system-ui": "5.0.10",
+  "expo-video": "2.2.2",
+  "jcore-react-native": "2.3.1",
+  "jpush-react-native": "3.2.0",
+  "llama.rn": "0.6.2",
+  "lottie-react-native": "7.2.4",
+  "open-im-sdk-rn": "3.8.3-patch.3",
+  "react-airplay": "1.2.0",
+  "react-native-avoid-softinput": "7.0.2",
+  "react-native-background-actions": "4.0.1",
+  "react-native-ble-manager": "12.1.5",
+  "react-native-blob-util": "0.22.2",
+  "react-native-bootsplash": "6.3.10",
+  "react-native-compressor": "1.12.0",
+  "react-native-config": "1.5.5",
+  "react-native-device-info": "14.0.4",
+  "react-native-edge-to-edge": "1.6.2",
+  "react-native-fast-image": "8.6.3",
+  "react-native-gesture-handler": "2.27.2",
+  "react-native-get-random-values": "1.11.0",
+  "react-native-google-mobile-ads": "15.4.0",
+  "react-native-haptic-feedback": "2.3.3",
+  "react-native-iap": "13.0.1",
+  "react-native-image-picker": "8.2.1",
+  "react-native-keyboard-controller": "1.18.0",
+  "react-native-linear-gradient": "2.8.3",
+  "react-native-localize": "3.5.1",
+  "react-native-mmkv": "3.3.0",
+  "react-native-orientation-locker": "1.7.0",
+  "react-native-permissions": "5.4.2",
+  "react-native-quick-base64": "2.2.1",
+  "react-native-quick-crypto": "0.7.15",
+  "react-native-reanimated": "3.19.0",
+  "react-native-restart": "0.0.27",
+  "react-native-safe-area-context": "5.5.2",
+  "react-native-screens": "4.13.1",
+  "react-native-share": "12.1.0",
+  "react-native-svg": "15.12.0",
+  "react-native-track-player": "4.1.1",
+  "react-native-vector-icons": "10.2.0",
+  "react-native-video": "6.16.1",
+  "react-native-view-shot": "4.0.3",
+  "react-native-vlc-media-player": "1.0.89",
+  "react-native-volume-manager": "2.0.8",
+  "react-native-webview": "13.15.0",
+  "react-native-wgpu": "0.2.0",
+  "react-native-wifi-reborn": "4.13.6",
+  "react-native-zip-archive": "7.0.2"
+}

package/src/webpack.config.mjs

@@ -0,0 +1,161 @@
+// 导入Node.js和第三方依赖
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import fse from 'fs-extra';
+import webpack from 'webpack';
+import TerserPlugin from 'terser-webpack-plugin';
+import * as Repack from '@callstack/repack';
+import { ExpoModulesPlugin } from '@callstack/repack-plugin-expo-modules';
+import { ReanimatedPlugin } from '@callstack/repack-plugin-reanimated';
+
+// 获取当前文件和目录路径
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectPath = path.resolve(__dirname, '../../../');
+
+// 微前端暴露配置，通常为JSON字符串
+const appExposesOptions = process.env.APP_EXPOSES_OPTIONS;
+
+// 读取package.json，获取应用基本信息
+const appConfig = fse.readJsonSync(path.join(projectPath, './app.json'));
+// 读取依赖共享配置
+const dependencies = fse.readJsonSync(path.join(__dirname, './shared-output.json'));
+const htyf = appConfig.htyf || {}
+const htyfHostConfig = {
+  "version": htyf.version,
+  "name": htyf.name,
+  "appid": htyf.appid,
+  "appUrlConfig": htyf.appUrlConfig,
+  "zipUrl": htyf.zipUrl
+}
+// 记录构建时间戳
+const time = Date.now();
+
+// 构建Module Federation共享依赖对象
+const sharedObj = {};
+for (const key in dependencies) {
+  const p = dependencies[key];
+  sharedObj[key] = {
+    /** 是否运行为单例 */
+    singleton: true,
+    /** host模式下必须为true，微应用为false */
+    eager: false,
+    requiredVersion: p.version,
+  };
+}
+
+/**
+ * Webpack配置导出函数
+ * @param {object} env - 构建环境变量
+ * @returns {object} - Webpack配置对象
+ */
+export default (env = {}) => {
+  // 设置构建上下文
+  env.context = __dirname;
+  const { entry = './index.js', platform = 'ios' } = env;
+  const context = env.context || projectPath;
+  // 获取Repack的resolve配置
+  const _options = Repack.getResolveOptions();
+
+  // 解析微前端相关配置
+  let mpOptions = {};
+  if (appExposesOptions) {
+    mpOptions = JSON.parse(decodeURI(appExposesOptions));
+  }
+
+  // 基础Webpack配置
+  const mpConfig = {
+    context,
+    entry,
+    resolve: {
+      ..._options,
+    },
+    output: {
+      // 默认输出路径，host模式下会被覆盖
+      path: mpOptions.outputPath,
+      uniqueName: mpOptions.uniqueName,
+    },
+    module: {
+      rules: [
+        // 处理js/ts/tsx文件，使用babel-loader
+        {
+          test: /\.[cm]?[jt]sx?$/,
+          use: 'babel-loader',
+          type: 'javascript/auto',
+        },
+        // 处理静态资源（图片等），支持inline模式
+        ...Repack.getAssetTransformRules({
+          inline: true,
+        }),
+      ],
+    },
+    optimization: {
+      // 压缩配置，去除注释
+      minimizer: [
+        new TerserPlugin({
+          test: /\.(js)?bundle(\?.*)?$/i,
+          extractComments: false,
+          terserOptions: {
+            format: {
+              comments: false,
+            },
+          },
+        }),
+      ],
+      chunkIds: 'named', // 便于调试
+    },
+    plugins: [
+      // 注入全局常量（appid、版本、构建时间）
+      new webpack.DefinePlugin({
+        __APP_DEFINE_APPID__: `"${htyfHostConfig.name}"`,
+        __APP_DEFINE_VERSION__: `"${htyfHostConfig.version}"`,
+        __APP_DEFINE_BUILD_TIME__: `"${time}"`,
+      }),
+      // Repack主插件，支持extraChunks配置
+      new Repack.RepackPlugin(mpOptions.extraChunksPath ? {
+        platform,
+        extraChunks: [
+          {
+            include: /.*/,
+            type: 'remote',
+            outputPath: `${mpOptions.extraChunksPath}`,
+          },
+        ],
+      } : {
+        platform,
+      }),
+      // Expo模块支持
+      new ExpoModulesPlugin(),
+      // Reanimated支持
+      new ReanimatedPlugin(),
+      // Module Federation V2插件，支持host和remote两种模式
+      new Repack.plugins.ModuleFederationPluginV2(mpOptions.exposes ? {
+        // 微应用模式
+        name: mpOptions.name,
+        filename: mpOptions.filename,
+        exposes: mpOptions.exposes,
+        shared: {
+          ...sharedObj,
+          react: { singleton: true, eager: true },
+          'react-native': { singleton: true, eager: true },
+        },
+        shareStrategy: 'loaded-first',
+      } : {
+        // host模式
+        name: 'HTYF_HOST_APP',
+        remotes: {},
+        shared: {
+          ...sharedObj,
+          react: { singleton: true, eager: true },
+          'react-native': { singleton: true, eager: true },
+        },
+        shareStrategy: 'loaded-first',
+      }),
+      new webpack.optimize.LimitChunkCountPlugin({
+        maxChunks: 2, // 限制最大chunk数，便于远程加载
+      }),
+    ],
+  };
+
+  return mpConfig;
+};