@htyf-mp/cli 0.2.0-alpha.6 → 0.2.0-alpha.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@htyf-mp/cli",
-  "version": "0.2.0-alpha.6",
+  "version": "0.2.0-alpha.8",
   "description": "红糖云服app小程序模板-cli",
   "type": "module",
   "bin": {
@@ -43,6 +43,8 @@
     "@callstack/repack-plugin-reanimated": "^5.1.3",
     "@inquirer/prompts": "^7.8.0",
     "@inquirer/select": "^4.3.1",
+    "@module-federation/dts-plugin": "^0.21.6",
+    "@module-federation/enhanced": "^0.21.6",
     "adm-zip": "0.5.10",
     "boxen": "^8.0.1",
     "chalk": "^5.4.1",
@@ -50,6 +52,7 @@
     "fs-extra": "^11.3.0",
     "gradient-string": "^3.0.0",
     "inquirer": "^12.9.0",
+    "loader-utils": "^3.3.1",
     "lodash": "^4.17.21",
     "md5": "^2.3.0",
     "ora": "^8.2.0",
@@ -61,6 +64,7 @@
     "superstatic": "^9.2.0",
     "systeminformation": "^5.27.7",
     "terser-webpack-plugin": "^5.3.14",
+    "typescript": "^5.9.3",
     "uuid": "^9.0.1",
     "webpack": "^5.101.0",
     "webpack-cli": "^6.0.1"

package/src/HtyfImportsPlugin.mjs

@@ -1,12 +1,44 @@
-import path from 'path';
+import path from 'node:path';
 import fse from 'fs-extra';
-import { fileURLToPath } from 'url';
+import { fileURLToPath } from 'node:url';
+import { getOptions } from 'loader-utils';
 
+// ==================== 常量定义 ====================
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const sharedPkg = fse.readJSONSync(path.join(__dirname, '../shared-output.json'));
+const nodeModulesPath = path.join(__dirname, '../node_modules');
+
+// 预编译正则表达式以提高性能
+const PNPM_PACKAGE_REGEX = /node_modules\/(?:\.pnpm\/[^/]+\/node_modules\/)?((?:@[^/]+\/)?[^/]+)/;
+const DEFAULT_EXPORT_REGEX = /var\s+_default\s*=\s*exports(?:\.default|\["default"\])\s*=/g;
+const DEPENDENCY_PLACEHOLDER_REGEX = /__HTYF_DEPENDENCY__/g;
+const LEADING_WHITESPACE_REGEX = /^[ \t]+/gm;
 
 // 白名单：这些包即使有 native 代码也不需要检查（系统级或已特殊处理）
-const WHITELIST = [];
+const WHITELIST = new Set();
+
+// 错误消息分隔线
+const ERROR_SEPARATOR = '═══════════════════════════════════════';
+
+// ==================== 缓存和配置 ====================
+const versionCache = new Map();
+const nativeCodeCache = new Map();
+
+// 延迟加载共享配置，避免启动时错误
+let sharedPkg = null;
+function getSharedConfig() {
+  if (sharedPkg === null) {
+    try {
+      const configPath = path.join(__dirname, './shared-output.json');
+      sharedPkg = fse.pathExistsSync(configPath) ? fse.readJSONSync(configPath) : {};
+    } catch (error) {
+      console.warn(`[HtyfModulesPlugin] 读取共享配置失败: ${error.message}`);
+      sharedPkg = {};
+    }
+  }
+  return sharedPkg;
+}
+
+// ==================== 工具函数 ====================
 
 /**
  * 从模块路径中提取包名
@@ -14,41 +46,68 @@ const WHITELIST = [];
  * @returns {string|null} 包名，如果无法提取则返回 null
  */
 function extractPackageName(moduleContext) {
-  if (!moduleContext || !moduleContext.includes('node_modules')) {
+  if (!moduleContext?.includes('node_modules')) {
     return null;
   }
 
-  const parts = moduleContext.split('node_modules/');
-  if (parts.length < 2) {
-    return null;
-  }
+  const match = moduleContext.match(PNPM_PACKAGE_REGEX);
+  return match?.[1] || null;
+}
 
-  const packagePath = parts[1];
-  const segments = packagePath.split('/').filter(Boolean);
-  
-  if (segments.length === 0) {
-    return null;
+/**
+ * 检查包是否包含 native 代码（带缓存）
+ * @param {string} packageName - 包名
+ * @returns {boolean} 是否包含 native 代码
+ */
+function hasNativeCode(packageName) {
+  if (!packageName) {
+    return false;
   }
 
-  // 处理 scoped packages (@scope/package)
-  if (segments[0].startsWith('@') && segments.length >= 2) {
-    return `${segments[0]}/${segments[1]}`;
+  // 使用缓存避免重复的文件系统访问
+  if (nativeCodeCache.has(packageName)) {
+    return nativeCodeCache.get(packageName);
   }
 
-  return segments[0];
+  const packagePath = path.join(nodeModulesPath, packageName);
+  const iosPath = path.join(packagePath, 'ios');
+  const androidPath = path.join(packagePath, 'android');
+  
+  const hasNative = fse.pathExistsSync(iosPath) || fse.pathExistsSync(androidPath);
+  nativeCodeCache.set(packageName, hasNative);
+  
+  return hasNative;
 }
 
 /**
- * 检查包是否包含 native 代码
+ * 获取包版本（带缓存）
  * @param {string} packageName - 包名
- * @returns {boolean} 是否包含 native 代码
+ * @returns {string|null} 包版本，如果无法获取则返回 null
  */
-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);
+function getPackageVersion(packageName) {
+  if (!packageName) {
+    return null;
+  }
+
+  if (versionCache.has(packageName)) {
+    return versionCache.get(packageName);
+  }
+
+  const pkgJsonPath = path.join(nodeModulesPath, packageName, 'package.json');
+  let version = null;
+
+  try {
+    if (fse.pathExistsSync(pkgJsonPath)) {
+      const pkgJson = fse.readJsonSync(pkgJsonPath);
+      version = pkgJson.version || null;
+    }
+  } catch (error) {
+    // 静默失败，返回 null
+    version = null;
+  }
+
+  versionCache.set(packageName, version);
+  return version;
 }
 
 /**
@@ -57,7 +116,8 @@ function hasNativeCode(packageName) {
  * @returns {boolean} 是否在共享配置中
  */
 function isInSharedConfig(packageName) {
-  return sharedPkg && sharedPkg.hasOwnProperty(packageName);
+  const config = getSharedConfig();
+  return packageName && Object.hasOwn(config, packageName);
 }
 
 /**
@@ -66,7 +126,7 @@ function isInSharedConfig(packageName) {
  * @returns {boolean} 是否在白名单中
  */
 function isWhitelisted(packageName) {
-  return WHITELIST.includes(packageName);
+  return packageName && WHITELIST.has(packageName);
 }
 
 /**
@@ -75,28 +135,66 @@ function isWhitelisted(packageName) {
  * @returns {string} 格式化的错误消息
  */
 function formatErrorMessage(unsupportedPackages) {
+  if (!unsupportedPackages?.length) {
+    return '';
+  }
+
   const lines = [
     '',
-    '═══════════════════════════════════════',
+    ERROR_SEPARATOR,
     '  红糖云服暂不支持以下第三方 native 组件',
-    '═══════════════════════════════════════',
+    ERROR_SEPARATOR,
+    '',
+    ...unsupportedPackages.map((pkg, index) => `  ${index + 1}. ${pkg}`),
+    '',
+    ERROR_SEPARATOR,
     '',
   ];
 
-  unsupportedPackages.forEach((pkg, index) => {
-    lines.push(`  ${index + 1}. ${pkg}`);
-  });
-
-  lines.push('');
-  lines.push('═══════════════════════════════════════');
-  lines.push('');
-
   return lines.join('\n');
 }
 
+/**
+ * 去除模板字符串中的前导空白
+ * @param {TemplateStringsArray} strings - 模板字符串数组
+ * @param {...any} values - 插值变量
+ * @returns {string} 处理后的字符串
+ */
 function trimTemplateStrings(strings, ...values) {
-  let fullString = strings.reduce((acc, str, i) => acc + str + (values[i] || ''), '');
-  return fullString.replace(/^[ \t]+/gm, '');
+  const fullString = strings.reduce((acc, str, i) => acc + str + (values[i] || ''), '');
+  return fullString.replace(LEADING_WHITESPACE_REGEX, '');
+}
+
+// ==================== Webpack Loader ====================
+
+/**
+ * Webpack自定义loader，用于在目标模块的源码前后插入额外的代码片段。
+ * 可通过options.prependCode / options.appendCode分别指定插入内容。
+ *
+ * @param {string|Buffer} source 原始模块内容
+ * @returns {string} 处理后的模块内容
+ */
+export default function injectAppInfoLoader(source) {
+  this.cacheable?.();
+  
+  // 将 Buffer 转换为字符串
+  const originalSource = Buffer.isBuffer(source) ? source.toString('utf-8') : source;
+  
+  // 注入依赖信息属性
+  return `
+    ${originalSource}
+    try {
+      Object.defineProperty(_default, '__HTYF_MP_DEPENDENCY__', {
+        value: JSON.parse(__HTYF_DEPENDENCY_STRING_DATA__),
+        writable: false,
+        enumerable: false,
+        configurable: false
+      });
+      _default = exports.default = _default;
+    } catch (error) {
+      console.error(error);
+    }
+  `;
 }
 
 export class HtyfModulesPlugin {
@@ -104,42 +202,31 @@ export class HtyfModulesPlugin {
     this.config = appConfig;
   }
 
+  /**
+   * 应用插件到 Webpack 编译器
+   * @param {Compiler} compiler - Webpack 编译器实例
+   */
   apply(compiler) {
     const config = this.config;
 
-    // 分析第三方 native 模块
+    // 分析第三方依赖并生成报告
     compiler.hooks.emit.tapAsync('AnalyzeThirdPartyModulesPlugin', (compilation, callback) => {
       try {
-        const nativeModules = new Set();
+        const { dependencies, nativeModules } = this.collectDependencyInfo(compilation);
 
-        // 收集所有包含 native 代码的第三方模块
-        compilation.modules.forEach(module => {
-          if (!module.context) {
-            return;
-          }
+        // 获取 manifest 路径，如果未配置则使用默认路径（webpack output 路径下的 manifest.json）
+        const outputPath = compilation.outputOptions.path || compiler.options.output?.path;
+        const manifestPath = this.config.manifest || (outputPath ? path.join(outputPath, 'manifest.json') : null);
 
-          const packageName = extractPackageName(module.context);
-          if (!packageName) {
-            return;
-          }
+        // 持久化依赖报告
+        this.persistDependencyReport(dependencies, manifestPath);
 
-          if (hasNativeCode(packageName)) {
-            nativeModules.add(packageName);
-          }
-        });
-
-        // 检查不支持的包
-        const unsupportedPackages = Array.from(nativeModules).filter(pkg => {
-          // 跳过白名单中的包
-          if (isWhitelisted(pkg)) {
-            return false;
-          }
+        // 筛选出不支持的 native 包
+        const unsupportedPackages = Array.from(nativeModules).filter(
+          pkg => !isWhitelisted(pkg) && !isInSharedConfig(pkg)
+        );
 
-          // 如果不在共享配置中，则不支持
-          return !isInSharedConfig(pkg);
-        });
-
-        // 如果有不支持的包，抛出错误
+        // 如果存在不支持的包，抛出错误
         if (unsupportedPackages.length > 0) {
           const errorMessage = formatErrorMessage(unsupportedPackages);
           console.error(errorMessage);
@@ -152,6 +239,8 @@ export class HtyfModulesPlugin {
           return;
         }
 
+        // 替换依赖占位符
+        this.replaceDependencyPlaceholders(compilation, dependencies);
         callback();
       } catch (error) {
         callback(error);
@@ -163,22 +252,22 @@ export class HtyfModulesPlugin {
       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();
+          for (const filename of Object.keys(compilation.assets)) {
+            const asset = compilation.assets[filename];
+            if (!asset || typeof asset.source !== 'function') {
+              continue;
+            }
 
-              // 包裹代码
-              const wrappedSource = trimTemplateStrings`
+            const source = asset.source();
+            const wrappedSource = trimTemplateStrings`
               ${source}
-              `;
+            `;
 
-              // 更新文件内容
-              compilation.assets[filename] = {
-                source: () => wrappedSource,
-                size: () => wrappedSource.length,
-              };
-            }
+            // 更新文件内容
+            compilation.assets[filename] = {
+              source: () => wrappedSource,
+              size: () => wrappedSource.length,
+            };
           }
           callback();
         } catch (error) {
@@ -187,4 +276,116 @@ export class HtyfModulesPlugin {
       });
     }
   }
+
+  /**
+   * 收集依赖信息
+   * @param {Compilation} compilation - Webpack 编译对象
+   * @returns {{dependencies: Object, nativeModules: Set<string>}} 依赖信息
+   */
+  collectDependencyInfo(compilation) {
+    const dependencyMap = new Map();
+    const nativeModules = new Set();
+
+    for (const module of compilation.modules) {
+      if (!module.context) {
+        continue;
+      }
+
+      const packageName = extractPackageName(module.context);
+      if (!packageName) {
+        continue;
+      }
+
+      // 如果已经处理过该包，跳过
+      if (dependencyMap.has(packageName)) {
+        const existing = dependencyMap.get(packageName);
+        // 如果之前不是 native 模块，再次检查（可能之前检查失败）
+        if (!existing.nativeModule && hasNativeCode(packageName)) {
+          existing.nativeModule = true;
+          nativeModules.add(packageName);
+        }
+        continue;
+      }
+
+      // 首次处理该包
+      const nativeModule = hasNativeCode(packageName);
+      const dependencyInfo = {
+        name: packageName,
+        version: getPackageVersion(packageName),
+        nativeModule,
+      };
+
+      dependencyMap.set(packageName, dependencyInfo);
+      
+      if (nativeModule) {
+        nativeModules.add(packageName);
+      }
+    }
+
+    // 将 Map 转换为普通对象
+    const dependencies = Object.fromEntries(dependencyMap);
+
+    return {
+      dependencies,
+      nativeModules,
+    };
+  }
+
+  /**
+   * 持久化依赖报告到文件
+   * @param {Object} dependencies - 依赖信息对象
+   * @param {string|null} manifestPath - manifest 文件路径，如果未提供则使用配置中的 manifest
+   */
+  persistDependencyReport(dependencies = {}, manifestPath = null) {
+    const manifest = manifestPath || this.config.manifest;
+    if (!manifest) {
+      return;
+    }
+
+    try {
+      const reportDir = path.dirname(manifest);
+      fse.ensureDirSync(reportDir);
+      fse.writeJsonSync(
+        manifest,
+        { packages: dependencies },
+        { spaces: 2 }
+      );
+    } catch (error) {
+      console.warn(`[HtyfModulesPlugin] 写入依赖报告失败: ${error.message}`);
+    }
+  }
+
+  /**
+   * 替换依赖占位符
+   * @param {Compilation} compilation - Webpack 编译对象
+   * @param {Object} dependencies - 依赖信息对象
+   */
+  replaceDependencyPlaceholders(compilation, dependencies = {}) {
+    // 将依赖信息序列化为 JSON 字符串，并进行安全的字符串转义
+    const jsonString = JSON.stringify(dependencies);
+    // 转义反斜杠和单引号，用于嵌入到单引号字符串中
+    const escapedString = jsonString
+      .replace(/\\/g, '\\\\')  // 转义反斜杠
+      .replace(/'/g, "\\'");   // 转义单引号
+    const stringLiteral = `'${escapedString}'`;
+
+    // 遍历所有资源文件，替换占位符
+    for (const filename of Object.keys(compilation.assets)) {
+      const asset = compilation.assets[filename];
+      if (!asset || typeof asset.source !== 'function') {
+        continue;
+      }
+
+      const source = asset.source().toString();
+      if (!source.includes('__HTYF_DEPENDENCY_STRING_DATA__')) {
+        continue;
+      }
+
+      const replacedSource = source.replace(DEPENDENCY_PLACEHOLDER_REGEX, stringLiteral);
+      compilation.assets[filename] = {
+        source: () => replacedSource,
+        size: () => replacedSource.length,
+      };
+    }
+  }
 }

package/src/build.mjs

@@ -1,16 +1,18 @@
 import path from 'path';
-import fs from 'fs';
 import fse from 'fs-extra';
 import AdmZip from 'adm-zip';
+import { fileURLToPath } from 'node:url';
 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';
+import { getProjectRoot, guessGodotProjectDir } from './utils.mjs';
+import { exportGodot, promptGodotOptions } from './export_godot.mjs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
+const PROJECT_ROOT = getProjectRoot();
 
 /**
  * 压缩文件夹为zip文件
@@ -22,16 +24,16 @@ export async function handleZip(inputPath, outputPath) {
   Logger.info(`开始压缩文件夹: ${inputPath}`);
   Logger.info(`输出文件: ${outputPath}`);
 
-  if (!fs.existsSync(inputPath)) {
+  if (!(await fse.pathExists(inputPath))) {
     throw new Error(`输入路径不存在: ${inputPath}`);
   }
 
-  const stats = fs.statSync(inputPath);
+  const stats = await fse.stat(inputPath);
   if (!stats.isDirectory()) {
     throw new Error(`输入路径不是目录: ${inputPath}`);
   }
 
-  const files = fs.readdirSync(inputPath);
+  const files = await fse.readdir(inputPath);
   Logger.debug(`目录内容: ${files.length} 个文件/文件夹`);
 
   if (files.length === 0) {
@@ -56,7 +58,7 @@ export async function handleZip(inputPath, outputPath) {
     await admzip.writeZipPromise(zipPath);
     Logger.success(`压缩完成: ${zipPath}`);
 
-    const zipStats = fs.statSync(zipPath);
+    const zipStats = await fse.stat(zipPath);
     Logger.info(`ZIP文件大小: ${FileSystemUtils.formatFileSize(zipStats.size)}`);
 
     return zipPath;
@@ -71,7 +73,7 @@ export async function handleZip(inputPath, outputPath) {
  * @param {object} newAppInfo - 应用信息
  * @returns {Promise<string>} 压缩包路径
  */
-export async function mpBuildShell(newAppInfo) {
+export async function mpBuildShell(newAppInfo, isGodot) {
   Logger.info(`开始构建小程序包...`);
   Logger.info(`应用: ${newAppInfo.name}`);
   Logger.info(`应用ID: ${newAppInfo.appid}`);
@@ -94,22 +96,22 @@ export async function mpBuildShell(newAppInfo) {
     throw new Error('无法创建输出目录');
   }
 
-  const version = newAppInfo.version;
-  const appid = newAppInfo.appid;
+  const { version, appid } = newAppInfo;
   const scriptName = getMiniAppScriptId(appid, version);
 
   const appJson = {
     type: 'app',
     engines: '2.0.0',
     name: newAppInfo.name,
-    appid: appid,
-    version: version,
+    appid,
+    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');
+  let outputPath = path.join(mpOutputPath, 'dist');
+  const distPackagePath = path.join(mpOutputPath, 'dist.dgz');
+  const rootIndexPath = path.join(tempPath, '..', 'index.js');
 
   const mpOptions = {
     name: scriptName,
@@ -117,25 +119,46 @@ export async function mpBuildShell(newAppInfo) {
     exposes: {
       'App': newAppInfo.entry,
     },
-    outputPath: path.join(mpOutputPath, './build'),
+    outputPath: path.join(mpOutputPath, 'build'),
     extraChunksPath: outputPath,
+    manifest: path.join(mpOutputPath, 'build'),
   };
 
   const appJsonPath = path.join(mpOutputPath, 'app.json');
-  fs.writeFileSync(appJsonPath, JSON.stringify(appJson, undefined, 2));
+  await fse.writeJson(appJsonPath, appJson, { spaces: 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`));
+    if (!isGodot) {
+      const command = `npx cross-env APP_ROOT_INDEX_PATH=${rootIndexPath} APP_EXPOSES_OPTIONS=${encodeURI(JSON.stringify(mpOptions))} webpack --config ${webpackConfigPath}`;
+      await CommandExecutor.execute(command, {
+        description: '构建小程序包',
+        timeout: 120000,
+        showCommand: false
+      });
+    } else {
+      Logger.info('检测到 Godot 项目，开始执行 Godot 导出流程...');
+      const defaultPlatform = ['android', 'ios'].includes(CONSTANTS.BUNDLE_PLATFORM) 
+        ? CONSTANTS.BUNDLE_PLATFORM 
+        : 'ios';
+      const godotDefaults = {
+        targetBaseDir: outputPath,
+        projectDir: guessGodotProjectDir(PROJECT_ROOT),
+        name: newAppInfo.name || 'GodotApp',
+        preset: defaultPlatform === 'android' ? 'Android' : 'iOS',
+        platform: defaultPlatform
+      };
+      const godotOptions = await promptGodotOptions(godotDefaults);
+      outputPath = path.resolve(godotOptions.targetBaseDir);
+      await fse.ensureDir(outputPath);
+      await fse.emptyDir(outputPath);
+      await exportGodot(godotOptions);
+    }
+
+    await fse.ensureDir(outputPath);
+    await fse.copy(appJsonPath, path.join(outputPath, 'app.json'));
+    const zipPath = await handleZip(outputPath, distPackagePath);
     Logger.success(`压缩包已创建: ${zipPath}`);
     return zipPath;
   } catch (error) {

package/src/export_godot.mjs

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { accessSync, constants as fsConstants } from 'node:fs';
+import process from 'node:process';
+import { homedir } from 'node:os';
+import fs from 'fs-extra';
+import AdmZip from 'adm-zip';
+import { execa } from 'execa';
+import inquirer from 'inquirer';
+
+const DEFAULT_GODOT_BIN = '/Applications/Godot.app/Contents/MacOS/Godot';
+const GODOT_CACHE_DIR = path.join(homedir() || process.cwd(), '.htyf');
+const GODOT_CACHE_FILE = path.join(GODOT_CACHE_DIR, 'godot-config.json');
+
+const PLATFORMS = {
+  IOS: 'ios',
+  ANDROID: 'android'
+};
+
+const PRESET_NAMES = {
+  [PLATFORMS.IOS]: 'iOS',
+  [PLATFORMS.ANDROID]: 'Android'
+};
+
+export async function promptGodotOptions(defaults = {}) {
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'targetBaseDir',
+      message: '请输入导出目标根目录:',
+      default: defaults.targetBaseDir || path.resolve(process.cwd(), './dist'),
+      validate: (input) => !!input.trim() || '目标根目录不能为空'
+    },
+    {
+      type: 'input',
+      name: 'projectDir',
+      message: '请输入 Godot 项目目录:',
+      default: defaults.projectDir || process.cwd(),
+      validate: (input) => !!input.trim() || '项目目录不能为空'
+    },
+    {
+      type: 'input',
+      name: 'name',
+      message: '请输入导出文件名称 (不含扩展名):',
+      default: defaults.name || 'GodotExport',
+      validate: (input) => !!input.trim() || '导出文件名称不能为空'
+    },
+    {
+      type: 'input',
+      name: 'preset',
+      message: '请输入 Godot 导出预设名称:',
+      default: defaults.preset || '',
+      validate: (input) => !!input.trim() || '导出预设名称不能为空'
+    },
+    {
+      type: 'list',
+      name: 'platform',
+      message: '请选择导出平台:',
+      choices: [
+        { name: 'iOS', value: PLATFORMS.IOS },
+        { name: 'Android', value: PLATFORMS.ANDROID }
+      ],
+      default: defaults.platform || 'ios'
+    }
+  ]);
+
+  return {
+    targetBaseDir: answers.targetBaseDir.trim(),
+    projectDir: answers.projectDir.trim(),
+    name: answers.name.trim(),
+    preset: answers.preset.trim(),
+    platform: answers.platform
+  };
+}
+
+function isExecutable(filePath) {
+  if (!filePath) return false;
+  if (!fs.existsSync(filePath)) return false;
+
+  try {
+    accessSync(filePath, fsConstants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function readCachedGodotPath() {
+  try {
+    if (!fs.existsSync(GODOT_CACHE_FILE)) {
+      return '';
+    }
+    const data = fs.readJsonSync(GODOT_CACHE_FILE);
+    return typeof data?.godotPath === 'string' ? data.godotPath : '';
+  } catch {
+    return '';
+  }
+}
+
+async function writeCachedGodotPath(godotPath) {
+  try {
+    await fs.ensureDir(GODOT_CACHE_DIR);
+    await fs.writeJson(GODOT_CACHE_FILE, { godotPath }, { spaces: 2 });
+  } catch {
+    // cache failures should not block execution
+  }
+}
+
+async function promptForGodotBinaryPath(defaultPath) {
+  const { godotPath } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'godotPath',
+      message: '请输入 Godot Editor 可执行文件路径:',
+      default: defaultPath,
+      validate: (input) => !!input.trim() || '路径不能为空'
+    }
+  ]);
+
+  return godotPath.trim();
+}
+
+async function resolveGodotBinary() {
+  const override = process.env.GODOT_EDITOR ? process.env.GODOT_EDITOR.trim() : '';
+  if (override && isExecutable(override)) {
+    return override;
+  }
+
+  const cached = readCachedGodotPath();
+  if (cached && isExecutable(cached)) {
+    return cached;
+  }
+
+  if (isExecutable(DEFAULT_GODOT_BIN)) {
+    await writeCachedGodotPath(DEFAULT_GODOT_BIN);
+    return DEFAULT_GODOT_BIN;
+  }
+
+  const fallbackDefault = override || cached || DEFAULT_GODOT_BIN;
+  const godotPath = await promptForGodotBinaryPath(fallbackDefault);
+
+  if (!isExecutable(godotPath)) {
+    throw new Error(`Godot 二进制文件不可执行: ${godotPath}`);
+  }
+
+  await writeCachedGodotPath(godotPath);
+  return godotPath;
+}
+
+async function runGodotCommand(godotBin, args) {
+  await execa(godotBin, args, { stdio: 'inherit' });
+}
+
+async function handleAndroidExport({ godotBin, projectDir, preset, targetBaseDir, name }) {
+  const assetsBaseDir = path.join(targetBaseDir, 'android', 'app', 'src', 'main', 'assets');
+  await fs.ensureDir(assetsBaseDir);
+
+  const zipPath = path.join(assetsBaseDir, `${name}.zip`);
+  await runGodotCommand(godotBin, ['--headless', '--path', projectDir, '--export-pack', preset, zipPath]);
+
+  const targetDir = path.join(assetsBaseDir, name);
+  await fs.remove(targetDir);
+  await fs.ensureDir(targetDir);
+
+  const zip = new AdmZip(zipPath);
+  zip.extractAllTo(targetDir, true);
+  await fs.remove(zipPath);
+}
+
+async function handleIosExport({ godotBin, projectDir, preset, targetBaseDir, name }) {
+  const assetsBaseDir = path.join(targetBaseDir, 'ios');
+  await fs.ensureDir(assetsBaseDir);
+  const outputPath = path.join(assetsBaseDir, `${name}.pck`);
+  await runGodotCommand(godotBin, ['--headless', '--path', projectDir, '--export-pack', preset, outputPath]);
+}
+
+export async function exportGodot(options) {
+  const godotBin = await resolveGodotBinary();
+  const { platform, projectDir, preset, targetBaseDir, name } = options;
+
+  // 执行两次 import 以确保资源正确导入
+  const importArgs = ['--headless', '--path', projectDir, '--import'];
+  await runGodotCommand(godotBin, importArgs);
+  await runGodotCommand(godotBin, importArgs);
+
+  switch (platform) {
+    case PLATFORMS.IOS:
+      await handleIosExport({ godotBin, projectDir, preset, targetBaseDir, name });
+      break;
+    case PLATFORMS.ANDROID:
+      await handleAndroidExport({ godotBin, projectDir, preset, targetBaseDir, name });
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${platform}. Supported: ${Object.values(PLATFORMS).join(', ')}`);
+  }
+}
+
+async function main() {
+  const options = await promptGodotOptions();
+  await exportGodot(options);
+}
+
+const isCliExecution = (() => {
+  if (!process.argv[1]) {
+    return false;
+  }
+  const cliUrl = pathToFileURL(process.argv[1]).href;
+  return cliUrl === import.meta.url;
+})();
+
+if (isCliExecution) {
+  main().catch((error) => {
+    console.error(error.message || error);
+    process.exitCode = 1;
+  });
+}
+

package/src/index.mjs

@@ -136,7 +136,10 @@ async function Start(action) {
 
   // 显示应用选择界面
   try {
-    const appInfo = fse.readJsonSync(path.join(projectPath, 'app.json')).htyf;
+    const appConfigPath = path.join(projectPath, 'app.json');
+    const appInfo = fse.readJsonSync(appConfigPath).htyf;
+    const isGodot = fse.existsSync(path.join(projectPath, 'game.godot'));
+
     if (!appInfo) {
       Logger.error('应用配置不存在，请先在app.json中配置htyf');
       return;
@@ -185,10 +188,10 @@ async function Start(action) {
 
     switch (action) {
       case ACTION_TYPES.MP_BUILD:
-        await mpBuildShell(newAppInfo);
+        await mpBuildShell(newAppInfo, isGodot);
         break;
       case ACTION_TYPES.MP_DEBUG:
-        await mpDebugShell(newAppInfo);
+        await mpDebugShell(newAppInfo, isGodot);
         break;
       default:
         Logger.error(`未知的操作类型: ${action}`);

package/src/utils.mjs

@@ -1,4 +1,5 @@
 import path from 'path';
+import fs from 'fs';
 import { fileURLToPath } from 'url';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -9,6 +10,28 @@ const __dirname = path.dirname(__filename);
  * @returns {string} 项目根目录路径
  */
 export function getProjectRoot() {
-  let currentPath = process.cwd() || __dirname;
-  return currentPath;
+  return process.cwd() || __dirname;
+}
+
+/**
+ * 猜测 Godot 项目目录
+ * @param {string} rootDir - 根目录
+ * @returns {string} Godot 项目目录路径
+ */
+export function guessGodotProjectDir(rootDir = getProjectRoot()) {
+  const candidates = [
+    rootDir,
+    path.join(rootDir, 'project'),
+    path.join(rootDir, 'game'),
+    path.join(rootDir, 'godot')
+  ];
+
+  for (const dir of candidates) {
+    const projectFile = path.join(dir, 'project.godot');
+    const gameFile = path.join(dir, 'game.godot');
+    if (fs.existsSync(projectFile) || fs.existsSync(gameFile)) {
+      return dir;
+    }
+  }
+  return rootDir;
 }

package/src/webpack.config.mjs

@@ -156,7 +156,10 @@ export default (env = {}) => {
         shareStrategy: 'loaded-first',
       }),
       new HtyfModulesPlugin({
-        codeSigning: true
+        codeSigning: true,
+        appid: mpOptions.appid,
+        version: mpOptions.version,
+        manifest: mpOptions.manifest,
       }),
       new webpack.optimize.LimitChunkCountPlugin({
         maxChunks: 2, // 限制最大chunk数，便于远程加载