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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@htyf-mp/cli",
-  "version": "0.2.0-alpha.7",
+  "version": "0.2.0-alpha.8",
   "description": "红糖云服app小程序模板-cli",
   "type": "module",
   "bin": {

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,26 +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'),
+    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;
 }