@playcraft/cli 0.0.10 → 0.0.12

package/dist/commands/build.js

@@ -1,6 +1,5 @@
 import path from 'path';
 import fs from 'fs/promises';
-import os from 'os';
 import pc from 'picocolors';
 import ora from 'ora';
 import { BaseBuilder, ViteBuilder, PlayableBuilder } from '@playcraft/build';
@@ -10,16 +9,24 @@ import inquirer from 'inquirer';
  * 检测是否是基础构建产物（多文件版本）
  */
 async function detectBaseBuild(dir) {
-    const indicators = [
+    // 基础文件：所有格式都需要
+    const baseIndicators = [
         path.join(dir, 'index.html'),
         path.join(dir, 'config.json'),
-        path.join(dir, '__start__.js'),
     ];
+    // Classic 格式特有
+    const classicIndicator = path.join(dir, '__start__.js');
+    // ESM 格式特有
+    const esmIndicator = path.join(dir, 'js/index.mjs');
     try {
-        await fs.access(indicators[0]);
-        await fs.access(indicators[1]);
-        await fs.access(indicators[2]);
-        return true;
+        // 检查基础文件
+        for (const indicator of baseIndicators) {
+            await fs.access(indicator);
+        }
+        // 检查格式特有文件（满足其一即可）
+        const isClassic = await fs.access(classicIndicator).then(() => true).catch(() => false);
+        const isESM = await fs.access(esmIndicator).then(() => true).catch(() => false);
+        return isClassic || isESM;
     }
     catch (error) {
         return false;
@@ -84,7 +91,36 @@ async function detectAmmoUsage(baseBuildDir) {
     try {
         const configContent = await fs.readFile(configPath, 'utf-8');
         const configJson = JSON.parse(configContent);
+        // 检查 application_properties.use3dPhysics
         use3dPhysics = Boolean(configJson.application_properties?.use3dPhysics);
+        // 如果 use3dPhysics 未设置，通过检查场景内容来推断
+        // 检查场景是否包含 3D 物理组件（rigidbody, collision 等）
+        if (!use3dPhysics) {
+            const scenesDir = baseBuildDir;
+            try {
+                const files = await fs.readdir(scenesDir);
+                for (const file of files) {
+                    if (file.endsWith('.json') && !['config.json', 'manifest.json'].includes(file)) {
+                        try {
+                            const sceneContent = await fs.readFile(path.join(scenesDir, file), 'utf-8');
+                            // 检查场景是否包含 3D 物理组件
+                            if (sceneContent.includes('"rigidbody"') ||
+                                sceneContent.includes('"collision"') ||
+                                sceneContent.includes('"joint"')) {
+                                use3dPhysics = true;
+                                break;
+                            }
+                        }
+                        catch {
+                            // 忽略单个场景读取失败
+                        }
+                    }
+                }
+            }
+            catch {
+                // 忽略目录读取失败
+            }
+        }
         if (configJson.assets) {
             for (const asset of Object.values(configJson.assets)) {
                 const assetData = asset;
@@ -119,6 +155,7 @@ async function detectAmmoUsage(baseBuildDir) {
 }
 async function analyzeBaseBuild(baseBuildDir, ammoReplacement) {
     const assetSizes = [];
+    const assetPaths = new Set(); // 用于去重
     let engineSize = 0;
     const ammoCheck = await detectAmmoUsage(baseBuildDir);
     const engineCandidates = [
@@ -151,10 +188,15 @@ async function analyzeBaseBuild(baseBuildDir, ammoReplacement) {
                 if (ammoReplacement && lowerUrl.includes('ammo')) {
                     continue;
                 }
+                // 跳过已经处理过的资源
+                if (assetPaths.has(cleanUrl)) {
+                    continue;
+                }
                 const assetPath = path.join(baseBuildDir, cleanUrl);
                 try {
                     const stats = await fs.stat(assetPath);
                     assetSizes.push({ path: cleanUrl, size: stats.size });
+                    assetPaths.add(cleanUrl); // 标记为已处理
                 }
                 catch (error) {
                     // ignore missing assets
@@ -174,10 +216,15 @@ async function analyzeBaseBuild(baseBuildDir, ammoReplacement) {
     };
 }
 export async function buildCommand(projectPath, options) {
+    // 解析项目路径 - 在 spinner 之前执行以便调试
+    const resolvedProjectPath = path.resolve(projectPath);
+    console.log(`[DEBUG] projectPath: ${projectPath}`);
+    console.log(`[DEBUG] resolvedProjectPath: ${resolvedProjectPath}`);
+    console.log(`[DEBUG] cwd: ${process.cwd()}`);
     const spinner = ora(pc.cyan('🔨 开始打包 Playable Ad...')).start();
+    // 清理选项（默认为 false，使用覆盖模式）
+    const shouldClean = options.clean === true;
     try {
-        // 解析项目路径
-        const resolvedProjectPath = path.resolve(projectPath);
         if (!options.baseOnly && !options.mode) {
             spinner.stop();
             const modeAnswer = await inquirer.prompt([
@@ -265,10 +312,22 @@ export async function buildCommand(projectPath, options) {
         }
         // 如果只执行基础构建
         if (options.baseOnly || options.mode === 'base') {
+            // 确定输出目录（Base Build 默认 ./build）
+            const baseBuildOutputDir = path.resolve(options.output || './build');
+            // 安全检查：防止输出目录与输入目录相同时被清理
+            const isSameAsInput = path.resolve(baseBuildOutputDir) === path.resolve(resolvedProjectPath);
+            // 如果输出目录与输入目录相同，警告用户并禁用清理
+            if (shouldClean && isSameAsInput) {
+                console.log(pc.yellow(`\n⚠️  输出目录与输入目录相同，跳过清理以保护源文件`));
+            }
+            else if (!shouldClean) {
+                console.log(pc.dim(`\nℹ️  使用覆盖模式，新文件将覆盖旧文件（使用 --clean 可清理旧目录）`));
+            }
             spinner.text = pc.cyan('执行阶段1: 基础构建...');
             const baseBuilder = new BaseBuilder(resolvedProjectPath, {
-                outputDir: path.resolve(options.output || './build'),
+                outputDir: baseBuildOutputDir,
                 selectedScenes,
+                clean: shouldClean && !isSameAsInput, // 清理逻辑由 BaseBuilder 内部处理
             });
             const baseBuild = await baseBuilder.build();
             spinner.succeed(pc.green('✅ 基础构建完成！'));
@@ -276,7 +335,7 @@ export async function buildCommand(projectPath, options) {
             console.log(pc.dim('💡 提示: 可以在浏览器中打开 index.html 测试游戏'));
             return;
         }
-        // 完整流程：阶段1 + 阶段2
+        // 完整流程：阶段1 + 阶段2（Playable Ads）
         const shouldRunPlayableOnly = options.mode === 'playable';
         // 验证平台
         const validPlatforms = [
@@ -294,30 +353,80 @@ export async function buildCommand(projectPath, options) {
             'adikteev',
             'remerge',
         ];
+        // 渠道输出格式配置（根据各渠道Playable规格对照表）
+        // 只支持 HTML: applovin, ironsource, unity, moloco, adikteev, remerge
+        // 只支持 ZIP: google, tiktok, liftoff, bigo, snapchat, inmobi
+        // 支持两种: facebook
+        const platformFormatConfig = {
+            facebook: {
+                formats: ['html', 'zip'],
+                default: 'html',
+                description: 'Facebook 支持两种格式'
+            },
+            applovin: { formats: ['html'], default: 'html' },
+            ironsource: { formats: ['html'], default: 'html' },
+            unity: { formats: ['html'], default: 'html' },
+            moloco: { formats: ['html'], default: 'html' },
+            adikteev: { formats: ['html'], default: 'html' },
+            remerge: { formats: ['html'], default: 'html' },
+            google: { formats: ['zip'], default: 'zip' },
+            tiktok: { formats: ['zip'], default: 'zip' },
+            liftoff: { formats: ['zip'], default: 'zip' },
+            bigo: { formats: ['zip'], default: 'zip' },
+            snapchat: { formats: ['zip'], default: 'zip' },
+            inmobi: { formats: ['zip'], default: 'zip' },
+        };
+        // 获取渠道支持的格式
+        const getPlatformFormats = (platform) => {
+            return platformFormatConfig[platform] || { formats: ['html', 'zip'], default: 'html' };
+        };
         if (!options.platform || !validPlatforms.includes(options.platform)) {
             spinner.stop();
-            const answers = await inquirer.prompt([
+            // 先选择平台
+            const platformAnswer = await inquirer.prompt([
                 {
                     type: 'list',
                     name: 'platform',
                     message: '选择目标平台:',
                     choices: validPlatforms,
                 },
-                {
-                    type: 'list',
-                    name: 'format',
-                    message: (answers) => answers.platform === 'facebook' ? '选择输出格式（Facebook 支持两种格式）:' : '选择输出格式:',
-                    choices: (answers) => answers.platform === 'facebook'
-                        ? [
-                            { name: 'HTML（单文件，最大 5MB，所有资源内联）', value: 'html' },
-                            { name: 'ZIP（多文件，最大 5MB，HTML 文件需 < 2MB）', value: 'zip' },
-                        ]
-                        : [
-                            { name: 'HTML（单文件）', value: 'html' },
-                            { name: 'ZIP（多文件）', value: 'zip' },
-                        ],
-                    default: 'html',
-                },
+            ]);
+            const selectedPlatform = platformAnswer.platform;
+            const formatConfig = getPlatformFormats(selectedPlatform);
+            // 根据平台支持的格式决定是否需要选择
+            let selectedFormat;
+            if (formatConfig.formats.length === 1) {
+                // 只支持一种格式，直接使用
+                selectedFormat = formatConfig.formats[0];
+                const formatName = selectedFormat === 'html' ? 'HTML（单文件）' : 'ZIP（多文件）';
+                console.log(pc.dim(`ℹ️  ${selectedPlatform} 渠道仅支持 ${formatName} 格式`));
+            }
+            else {
+                // 支持多种格式，让用户选择
+                const formatAnswer = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'format',
+                        message: formatConfig.description
+                            ? `选择输出格式（${formatConfig.description}）:`
+                            : '选择输出格式:',
+                        choices: formatConfig.formats.map(f => ({
+                            name: f === 'html'
+                                ? (selectedPlatform === 'facebook'
+                                    ? 'HTML（单文件，最大 5MB，所有资源内联）'
+                                    : 'HTML（单文件）')
+                                : (selectedPlatform === 'facebook'
+                                    ? 'ZIP（多文件，最大 5MB，HTML 文件需 < 2MB）'
+                                    : 'ZIP（多文件）'),
+                            value: f,
+                        })),
+                        default: formatConfig.default,
+                    },
+                ]);
+                selectedFormat = formatAnswer.format;
+            }
+            // 选择输出目录
+            const outputAnswer = await inquirer.prompt([
                 {
                     type: 'input',
                     name: 'output',
@@ -325,11 +434,24 @@ export async function buildCommand(projectPath, options) {
                     default: options.output || './dist',
                 },
             ]);
-            options.platform = answers.platform;
-            options.format = answers.format;
-            options.output = answers.output;
+            options.platform = selectedPlatform;
+            options.format = selectedFormat;
+            options.output = outputAnswer.output;
             spinner.start(pc.cyan('🔨 开始打包 Playable Ad...'));
         }
+        else {
+            // 命令行已指定平台，检查格式是否符合要求
+            const formatConfig = getPlatformFormats(options.platform);
+            if (options.format && !formatConfig.formats.includes(options.format)) {
+                const supportedFormats = formatConfig.formats.join(' 或 ');
+                console.log(pc.yellow(`\n⚠️  ${options.platform} 渠道仅支持 ${supportedFormats} 格式，已自动切换为 ${formatConfig.default}`));
+                options.format = formatConfig.default;
+            }
+            else if (!options.format) {
+                // 未指定格式，使用默认值
+                options.format = formatConfig.default;
+            }
+        }
         // 解析配置
         const buildOptions = {
             platform: options.platform,
@@ -350,18 +472,44 @@ export async function buildCommand(projectPath, options) {
             modelCompression: options.modelCompression,
             // 场景选择
             selectedScenes,
+            // ESM 选项
+            ...(options.esmMode ? { esmMode: options.esmMode } : {}),
         };
         if (fileConfig) {
             Object.assign(buildOptions, fileConfig);
         }
-        // 1. 检测输入类型
+        // 1. 先检测输入类型（在清理目录之前！）
         spinner.text = pc.cyan('检测项目类型...');
         const isBaseBuild = await detectBaseBuild(resolvedProjectPath);
+        // 2. 验证 playable-only 模式的前置条件
+        if (shouldRunPlayableOnly && !isBaseBuild) {
+            // 检查是否是原始 PlayCanvas 编辑器项目
+            const isEditorProject = await fs.access(path.join(resolvedProjectPath, 'scenes.json')).then(() => true).catch(() => false);
+            if (isEditorProject) {
+                throw new Error('检测到这是 PlayCanvas 编辑器项目，不是多文件构建产物。\n\n' +
+                    '请使用以下命令之一：\n' +
+                    '  1. playcraft build <项目路径>          # 完整构建（推荐）\n' +
+                    '  2. playcraft build-base <项目路径>     # 先生成多文件产物\n' +
+                    '     playcraft build-playable <产物路径> # 再转换为 Playable\n\n' +
+                    '💡 提示: build-playable 命令仅用于已有的多文件构建产物');
+            }
+            throw new Error('当前目录不是多文件构建产物，请先运行完整构建或使用 build-base 生成。');
+        }
+        // 3. 验证通过后，显示清理/覆盖模式提示（实际清理由 ViteBuilder 内部处理）
+        const playableOutputDir = buildOptions.outputDir || path.resolve(options.output || './dist');
+        // 安全检查：防止输出目录与输入目录相同时被清理
+        const isSameAsInput = path.resolve(playableOutputDir) === path.resolve(resolvedProjectPath);
+        if (shouldClean && isSameAsInput) {
+            console.log(pc.yellow(`\n⚠️  输出目录与输入目录相同，跳过清理以保护源文件`));
+        }
+        else if (!shouldClean) {
+            console.log(pc.dim(`\nℹ️  使用覆盖模式，新文件将覆盖旧文件（使用 --clean 可清理旧目录）`));
+        }
+        // 注意：ViteBuilder 内部会通过 emptyOutDir: true 自动清空输出目录
+        // 4. 确定 baseBuildDir
         let baseBuildDir;
         if (shouldRunPlayableOnly) {
-            if (!isBaseBuild) {
-                throw new Error('当前目录不是多文件构建产物，请先运行完整构建或使用 build-base 生成。');
-            }
+            // 已经在上面验证过 isBaseBuild === true
             spinner.text = pc.cyan('✅ 使用多文件构建产物，直接执行阶段2');
             baseBuildDir = resolvedProjectPath;
         }
@@ -373,10 +521,13 @@ export async function buildCommand(projectPath, options) {
         else {
             // 输入是源代码或官方构建，先执行阶段1
             spinner.text = pc.cyan('执行阶段1: 基础构建...');
-            const tempDir = path.join(os.tmpdir(), `playcraft-base-build-${Date.now()}`);
+            // 将临时目录放在项目所在目录下，避免跨盘符路径问题（Windows 上 C:\Temp 和 D:\project 会导致 Vite 路径计算错误）
+            const tempDir = path.join(resolvedProjectPath, '.playcraft-temp', `base-build-${Date.now()}`);
             const baseBuilder = new BaseBuilder(resolvedProjectPath, {
                 outputDir: tempDir,
                 selectedScenes,
+                analyze: buildOptions.analyze,
+                analyzeReportPath: buildOptions.analyze ? 'base-bundle-report.html' : undefined,
             });
             const baseBuild = await baseBuilder.build();
             baseBuildDir = baseBuild.outputDir;
@@ -390,18 +541,48 @@ export async function buildCommand(projectPath, options) {
         else if (options.replaceAmmo && ammoCheck.hasAmmo && ammoCheck.suggestedEngine) {
             buildOptions.ammoReplacement = ammoCheck.suggestedEngine;
         }
-        else if (ammoCheck.hasAmmo && ammoCheck.suggestedEngine && !buildOptions.ammoReplacement) {
+        else if (ammoCheck.hasAmmo && !buildOptions.ammoReplacement) {
             spinner.stop();
-            const replaceAnswer = await inquirer.prompt([
-                {
-                    type: 'confirm',
-                    name: 'replaceAmmo',
-                    message: `检测到 Ammo.js，是否替换为 ${ammoCheck.suggestedEngine} 并打包内置？`,
-                    default: false,
-                },
-            ]);
-            if (replaceAnswer.replaceAmmo) {
-                buildOptions.ammoReplacement = ammoCheck.suggestedEngine;
+            // 根据是否使用 3D 物理提供不同的选项
+            const physicsType = ammoCheck.use3dPhysics ? '3D' : '2D';
+            if (ammoCheck.use3dPhysics) {
+                // 3D 项目 - 可以使用 Cannon.js 替换
+                console.log(pc.yellow(`⚠️  检测到 3D 物理项目，Ammo.js 约 1.8MB`));
+                console.log(pc.gray(`   提示: Cannon.js (~400KB) 可以减小 75% 的体积`));
+                const replaceAnswer = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'ammoAction',
+                        message: `如何处理 Ammo.js？`,
+                        choices: [
+                            { name: '保留 Ammo.js（完整物理功能，文件较大）', value: 'keep' },
+                            { name: '替换为 Cannon.js（推荐 3D 项目，~400KB，自动适配）', value: 'cannon' },
+                        ],
+                        default: 'cannon',
+                    },
+                ]);
+                if (replaceAnswer.ammoAction === 'cannon') {
+                    buildOptions.ammoReplacement = 'cannon';
+                    console.log(pc.green('   ✓ 将使用 Cannon.js 替换 Ammo.js（自动兼容 rigidbody API）'));
+                }
+            }
+            else {
+                // 2D 项目 - 可以使用 p2.js 替换
+                const replaceAnswer = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'ammoAction',
+                        message: `检测到 Ammo.js（项目使用 ${physicsType} 物理），如何处理？`,
+                        choices: [
+                            { name: '不替换（保留 Ammo.js，文件较大）', value: 'keep' },
+                            { name: '替换为 p2.js（推荐 2D 项目，~60KB）', value: 'p2' },
+                        ],
+                        default: 'p2',
+                    },
+                ]);
+                if (replaceAnswer.ammoAction === 'p2') {
+                    buildOptions.ammoReplacement = 'p2';
+                }
             }
             spinner.start(pc.cyan('🔨 开始打包 Playable Ad...'));
         }
@@ -434,12 +615,25 @@ export async function buildCommand(projectPath, options) {
         console.log(`  - 总计: ${totalMB} MB ${status} (限制: ${limitMB} MB)`);
         console.log('\n' + pc.green(`输出: ${outputPath}`));
         if (buildOptions.analyze) {
-            const reportPath = buildOptions.analyzeReportPath
+            // 从 Base Build 复制分析报告到最终输出目录
+            const baseReportPath = path.join(baseBuildDir, 'base-bundle-report.html');
+            const finalReportPath = buildOptions.analyzeReportPath
                 ? buildOptions.analyzeReportPath
                 : path.join(buildOptions.outputDir || './dist', 'bundle-report.html');
+            let reportExists = false;
+            try {
+                await fs.access(baseReportPath);
+                await fs.copyFile(baseReportPath, finalReportPath);
+                reportExists = true;
+            }
+            catch {
+                // 报告文件不存在（例如从官方构建产物直接复制时），这是正常的
+            }
             const analysis = await analyzeBaseBuild(baseBuildDir, buildOptions.ammoReplacement);
             console.log('\n' + pc.bold('分析报告:'));
-            console.log(`  - 可视化报告: ${reportPath}`);
+            if (reportExists) {
+                console.log(`  - 可视化报告: ${finalReportPath}`);
+            }
             if (analysis.engineSize > 0) {
                 const engineMB = (analysis.engineSize / 1024 / 1024).toFixed(2);
                 console.log(`  - 引擎大小: ${engineMB} MB`);
@@ -447,22 +641,30 @@ export async function buildCommand(projectPath, options) {
             if (analysis.topAssets.length > 0) {
                 console.log('  - 资源 Top:');
                 analysis.topAssets.forEach((asset) => {
-                    const sizeMB = (asset.size / 1024 / 1024).toFixed(2);
-                    console.log(`    • ${asset.path}: ${sizeMB} MB`);
+                    const sizeKB = asset.size / 1024;
+                    const sizeMB = sizeKB / 1024;
+                    // 自动选择合适的单位
+                    const sizeStr = sizeMB >= 0.01
+                        ? `${sizeMB.toFixed(2)} MB`
+                        : `${sizeKB.toFixed(2)} KB`;
+                    console.log(`    • ${asset.path}: ${sizeStr}`);
                 });
             }
             if (analysis.hasAmmo) {
                 console.log(pc.yellow(`  - 检测到 Ammo.js，建议替换为 ${analysis.suggestedEngine}`));
             }
         }
-        // 清理临时目录
-        if (!isBaseBuild && baseBuildDir.startsWith(os.tmpdir())) {
-            try {
-                await fs.rm(baseBuildDir, { recursive: true, force: true });
-            }
-            catch (error) {
-                // 忽略清理错误
-            }
+        // 清理临时目录（调试时注释掉）
+        if (!isBaseBuild && baseBuildDir.includes('.playcraft-temp')) {
+            // 调试：暂时保留临时目录
+            console.log(pc.yellow(`[DEBUG] 临时目录保留在: ${baseBuildDir}`));
+            // try {
+            //   // 清理整个 .playcraft-temp 目录
+            //   const tempBaseDir = path.join(resolvedProjectPath, '.playcraft-temp');
+            //   await fs.rm(tempBaseDir, { recursive: true, force: true });
+            // } catch (error) {
+            //   // 忽略清理错误
+            // }
         }
     }
     catch (error) {

package/dist/commands/fix-ids.js

@@ -0,0 +1,43 @@
+/**
+ * fix-ids 命令：修复已导入项目的 ID 映射（将 Sandbox 中的 PlayCanvas ID 转换为 PlayCraft numericId）
+ */
+import pc from 'picocolors';
+export async function fixIdsCommand(options) {
+    const { projectId, apiUrl, token } = options;
+    const baseUrl = (apiUrl || process.env.BACKEND_API_URL || process.env.PLAYCRAFT_URL || 'http://localhost:3001').replace(/\/+$/, '');
+    const url = `${baseUrl}/api/projects/${encodeURIComponent(projectId)}/fix-ids`;
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (token || process.env.PLAYCRAFT_TOKEN) {
+        headers['Authorization'] = `Bearer ${token || process.env.PLAYCRAFT_TOKEN}`;
+    }
+    if (process.env.NEXT_PUBLIC_LOCAL_AUTH_BYPASS === 'true' && process.env.NEXT_PUBLIC_LOCAL_USER) {
+        headers['X-Local-User'] = process.env.NEXT_PUBLIC_LOCAL_USER;
+    }
+    console.log(pc.dim(`Fixing ID mapping for project ${projectId}...`));
+    console.log(pc.dim(`POST ${url}`));
+    try {
+        const res = await fetch(url, {
+            method: 'POST',
+            headers,
+        });
+        const body = await res.json().catch(() => ({}));
+        if (!res.ok) {
+            const msg = body.message || res.statusText || String(res.status);
+            console.error(pc.red(`Failed to fix ID mapping: ${msg}`));
+            process.exit(1);
+        }
+        if (body.success !== true) {
+            console.error(pc.red('Unexpected response from server'));
+            process.exit(1);
+        }
+        console.log(pc.green('ID mapping fixed successfully'));
+        console.log(pc.dim('Please reload the editor to see changes.'));
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(pc.red(`Request failed: ${message}`));
+        process.exit(1);
+    }
+}