@playcraft/cli 0.0.1

package/dist/commands/inspect.js

@@ -0,0 +1,209 @@
+import fs from 'fs/promises';
+import path from 'path';
+import pc from 'picocolors';
+/**
+ * 检查项目类型和结构
+ */
+export async function inspectCommand(projectPath) {
+    console.log(pc.cyan('\n🔍 正在检查项目...\n'));
+    try {
+        const projectDir = path.resolve(projectPath);
+        // 检查目录是否存在
+        try {
+            await fs.access(projectDir);
+        }
+        catch (error) {
+            console.error(pc.red(`❌ 项目目录不存在: ${projectDir}`));
+            process.exit(1);
+        }
+        console.log(pc.dim(`项目路径: ${projectDir}\n`));
+        // 检查文件存在性
+        const files = {
+            // Build 项目标识
+            'index.html': false,
+            '__start__.js': false,
+            '__settings__.js': false,
+            '__loading__.js': false,
+            '__game_scripts.js': false,
+            'config.json': false,
+            // 源代码项目标识
+            'manifest.json': false,
+            'assets.json': false,
+            'scenes.json': false,
+            'project.json': false,
+            // 其他
+            'files': false,
+            'assets': false,
+            'scenes': false,
+        };
+        for (const file of Object.keys(files)) {
+            try {
+                const filePath = path.join(projectDir, file);
+                await fs.access(filePath);
+                files[file] = true;
+            }
+            catch (error) {
+                // 文件不存在
+            }
+        }
+        // 判断项目类型
+        let projectType = 'unknown';
+        let confidence = 0;
+        // 检查是否是 Build 项目
+        const buildFiles = ['index.html', '__start__.js', 'config.json'];
+        const buildScore = buildFiles.filter(f => files[f]).length;
+        if (buildScore >= 2) {
+            projectType = 'build';
+            confidence = (buildScore / buildFiles.length) * 100;
+        }
+        // 检查是否是 PlayCraft 源代码
+        else if (files['manifest.json']) {
+            projectType = 'playcraft-source';
+            confidence = 90;
+            if (files['assets'] && files['scenes']) {
+                confidence = 100;
+            }
+        }
+        // 检查是否是 PlayCanvas 源代码
+        else if (files['assets.json'] || files['scenes.json']) {
+            projectType = 'playcanvas-source';
+            const pcFiles = ['assets.json', 'scenes.json', 'project.json'];
+            const pcScore = pcFiles.filter(f => files[f]).length;
+            confidence = (pcScore / pcFiles.length) * 100;
+        }
+        // 输出结果
+        console.log(pc.bold('📊 项目分析结果:\n'));
+        // 项目类型
+        console.log(`${pc.bold('项目类型:')} ${getProjectTypeDisplay(projectType, confidence)}`);
+        console.log(`${pc.bold('置信度:')} ${confidence.toFixed(0)}%\n`);
+        // 文件清单
+        console.log(pc.bold('📁 文件清单:\n'));
+        if (projectType === 'build') {
+            console.log(pc.green('✅ Build 项目文件:'));
+            printFileList(files, ['index.html', '__start__.js', '__settings__.js', '__game_scripts.js', 'config.json', '__loading__.js']);
+            if (files['files']) {
+                console.log(pc.green('  ✓ files/ 目录'));
+            }
+        }
+        else if (projectType === 'playcraft-source') {
+            console.log(pc.yellow('📝 PlayCraft 源代码文件:'));
+            printFileList(files, ['manifest.json', 'assets', 'scenes']);
+        }
+        else if (projectType === 'playcanvas-source') {
+            console.log(pc.yellow('📝 PlayCanvas 源代码文件:'));
+            printFileList(files, ['assets.json', 'scenes.json', 'project.json', 'files']);
+        }
+        else {
+            console.log(pc.red('❌ 无法识别的项目结构'));
+            console.log(pc.dim('\n找到的文件:'));
+            for (const [file, exists] of Object.entries(files)) {
+                if (exists) {
+                    console.log(pc.dim(`  - ${file}`));
+                }
+            }
+        }
+        // 建议
+        console.log('\n' + pc.bold('💡 建议:\n'));
+        if (projectType === 'build') {
+            console.log(pc.green('✅ 这是一个构建后的项目，可以直接打包为 Playable Ad'));
+            console.log(pc.dim('   运行: playcraft build --platform facebook'));
+        }
+        else if (projectType === 'playcraft-source' || projectType === 'playcanvas-source') {
+            console.log(pc.yellow('⚠️  这是源代码项目，建议先构建再打包\n'));
+            console.log(pc.cyan('方式 1 (推荐): 使用 PlayCanvas REST API 构建'));
+            console.log(pc.dim('   1. 在 PlayCanvas Editor 中发布项目'));
+            console.log(pc.dim('   2. 使用 REST API 下载构建'));
+            console.log(pc.dim('   3. 运行: playcraft build --platform facebook\n'));
+            console.log(pc.cyan('方式 2: 使用本地构建（实验性功能）'));
+            console.log(pc.dim('   运行: playcraft build --platform facebook --auto-build\n'));
+            console.log(pc.cyan('方式 3: 直接从源代码打包（可能不完整）'));
+            console.log(pc.dim('   运行: playcraft build --platform facebook --skip-build'));
+        }
+        else {
+            console.log(pc.red('❌ 无法识别项目类型，请确保:'));
+            console.log(pc.dim('   - Build 项目包含: index.html, config.json, __start__.js'));
+            console.log(pc.dim('   - PlayCraft 源代码包含: manifest.json'));
+            console.log(pc.dim('   - PlayCanvas 源代码包含: assets.json 和 scenes.json'));
+        }
+        console.log('');
+        // 读取并显示关键信息
+        await printProjectInfo(projectDir, files, projectType);
+    }
+    catch (error) {
+        console.error(pc.red(`\n❌ 检查失败: ${error.message}`));
+        process.exit(1);
+    }
+}
+function getProjectTypeDisplay(type, confidence) {
+    const emoji = {
+        'build': '✅',
+        'playcraft-source': '📝',
+        'playcanvas-source': '📝',
+        'unknown': '❓',
+    }[type] || '❓';
+    const label = {
+        'build': pc.green('Build 项目（构建后）'),
+        'playcraft-source': pc.yellow('PlayCraft 源代码'),
+        'playcanvas-source': pc.yellow('PlayCanvas 源代码'),
+        'unknown': pc.red('未知类型'),
+    }[type] || pc.red('未知类型');
+    return `${emoji} ${label}`;
+}
+function printFileList(files, keys) {
+    for (const key of keys) {
+        if (files[key]) {
+            console.log(pc.green(`  ✓ ${key}`));
+        }
+        else {
+            console.log(pc.dim(`  ✗ ${key}`));
+        }
+    }
+}
+async function printProjectInfo(projectDir, files, projectType) {
+    console.log(pc.bold('📋 项目信息:\n'));
+    try {
+        if (projectType === 'build' && files['config.json']) {
+            const configPath = path.join(projectDir, 'config.json');
+            const configContent = await fs.readFile(configPath, 'utf-8');
+            const config = JSON.parse(configContent);
+            console.log(pc.dim('  项目名称:'), config.project_name || 'N/A');
+            console.log(pc.dim('  项目 ID:'), config.project_id || 'N/A');
+            console.log(pc.dim('  场景数量:'), config.scenes?.length || 0);
+            console.log(pc.dim('  资产数量:'), config.assets ? Object.keys(config.assets).length : 0);
+        }
+        else if (projectType === 'playcraft-source' && files['manifest.json']) {
+            const manifestPath = path.join(projectDir, 'manifest.json');
+            const manifestContent = await fs.readFile(manifestPath, 'utf-8');
+            const manifest = JSON.parse(manifestContent);
+            console.log(pc.dim('  项目名称:'), manifest.project?.name || 'N/A');
+            console.log(pc.dim('  项目 ID:'), manifest.project?.id || 'N/A');
+            console.log(pc.dim('  场景数量:'), manifest.scenes?.length || 0);
+            console.log(pc.dim('  资产数量:'), manifest.assets?.length || 0);
+        }
+        else if (projectType === 'playcanvas-source') {
+            if (files['project.json']) {
+                const projectJsonPath = path.join(projectDir, 'project.json');
+                const projectContent = await fs.readFile(projectJsonPath, 'utf-8');
+                const project = JSON.parse(projectContent);
+                console.log(pc.dim('  项目名称:'), project.name || 'N/A');
+                console.log(pc.dim('  项目 ID:'), project.id || 'N/A');
+            }
+            if (files['assets.json']) {
+                const assetsPath = path.join(projectDir, 'assets.json');
+                const assetsContent = await fs.readFile(assetsPath, 'utf-8');
+                const assets = JSON.parse(assetsContent);
+                console.log(pc.dim('  资产数量:'), assets.length || 0);
+            }
+            if (files['scenes.json']) {
+                const scenesPath = path.join(projectDir, 'scenes.json');
+                const scenesContent = await fs.readFile(scenesPath, 'utf-8');
+                const scenes = JSON.parse(scenesContent);
+                console.log(pc.dim('  场景数量:'), scenes.length || 0);
+            }
+        }
+    }
+    catch (error) {
+        console.log(pc.dim('  无法读取项目信息'));
+    }
+    console.log('');
+}

package/dist/commands/logs.js

@@ -0,0 +1,121 @@
+import { Logger } from '../logger.js';
+import { loadConfig } from '../config.js';
+import pc from 'picocolors';
+import ora from 'ora';
+import { createReadStream, watchFile, unwatchFile } from 'fs';
+import { createInterface } from 'readline';
+export async function logsCommand(options) {
+    const spinner = ora('加载日志...').start();
+    try {
+        let projectId = options.project;
+        // 如果没有指定项目，尝试从配置文件读取
+        if (!projectId) {
+            try {
+                const config = await loadConfig({});
+                projectId = config.projectId;
+            }
+            catch (error) {
+                // 忽略配置加载错误
+            }
+        }
+        if (!projectId) {
+            spinner.fail('未指定项目 ID');
+            console.error(pc.red('请使用 --project 参数指定项目 ID'));
+            process.exit(1);
+        }
+        const logFile = Logger.getLogFilePath(projectId);
+        if (options.follow) {
+            // 实时跟踪模式
+            spinner.succeed('实时跟踪日志（按 Ctrl+C 退出）');
+            console.log(pc.cyan(`\n📋 日志文件: ${logFile}\n`));
+            await tailLogFile(logFile);
+        }
+        else {
+            // 显示最后 N 行
+            const lines = options.lines ? parseInt(options.lines, 10) : undefined;
+            const logLines = await Logger.readLogFile(projectId, lines);
+            if (logLines.length === 0) {
+                spinner.succeed('日志文件为空');
+                console.log(pc.yellow('没有找到日志内容\n'));
+                process.exit(0);
+            }
+            spinner.succeed(`显示最后 ${logLines.length} 行日志`);
+            console.log(pc.cyan(`\n📋 日志文件: ${logFile}\n`));
+            for (const line of logLines) {
+                console.log(line);
+            }
+            console.log();
+        }
+    }
+    catch (error) {
+        spinner.fail('加载日志失败');
+        console.error(pc.red(`错误: ${error.message}`));
+        process.exit(1);
+    }
+}
+async function tailLogFile(logFile) {
+    return new Promise((resolve, reject) => {
+        const stream = createReadStream(logFile, { encoding: 'utf-8' });
+        const rl = createInterface({
+            input: stream,
+            crlfDelay: Infinity,
+        });
+        // 先读取最后几行（如果文件很大）
+        let lastLines = [];
+        rl.on('line', (line) => {
+            lastLines.push(line);
+            if (lastLines.length > 10) {
+                lastLines.shift();
+            }
+        });
+        rl.on('close', () => {
+            // 显示最后几行
+            for (const line of lastLines) {
+                console.log(line);
+            }
+            // 然后开始监控文件变化
+            const watcher = watchFile(logFile, { interval: 1000 }, (curr, prev) => {
+                if (curr.mtime > prev.mtime) {
+                    // 文件已更新，读取新内容
+                    const tailStream = createReadStream(logFile, {
+                        encoding: 'utf-8',
+                        start: prev.size,
+                    });
+                    tailStream.on('data', (chunk) => {
+                        const content = typeof chunk === 'string' ? chunk : chunk.toString('utf-8');
+                        const lines = content.split('\n').filter((l) => l.trim());
+                        for (const line of lines) {
+                            console.log(line);
+                        }
+                    });
+                }
+            });
+            // 处理 Ctrl+C
+            process.on('SIGINT', () => {
+                unwatchFile(logFile);
+                console.log(pc.yellow('\n\n停止跟踪日志\n'));
+                resolve();
+            });
+        });
+        stream.on('error', (error) => {
+            if (error.code === 'ENOENT') {
+                console.log(pc.yellow('日志文件不存在，等待创建...\n'));
+                // 等待文件创建
+                const watcher = watchFile(logFile, { interval: 1000 }, (curr) => {
+                    if (curr.size > 0) {
+                        unwatchFile(logFile);
+                        tailLogFile(logFile).then(resolve).catch(reject);
+                    }
+                });
+                process.on('SIGINT', () => {
+                    unwatchFile(logFile);
+                    console.log(pc.yellow('\n\n停止跟踪日志\n'));
+                    resolve();
+                });
+            }
+            else {
+                reject(error);
+            }
+        });
+    });
+}

package/dist/commands/start.js

@@ -0,0 +1,284 @@
+import { spawn } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { loadConfig } from '../config.js';
+import { ProcessManager } from '../process-manager.js';
+import { isPortAvailable, findAvailablePort } from '../port-utils.js';
+import { Logger } from '../logger.js';
+import { createServer } from '../server.js';
+import { SocketServer } from '../socket.js';
+import { Watcher } from '../watcher.js';
+import { FSHandler } from '../fs-handler.js';
+import http from 'http';
+import pc from 'picocolors';
+import ora from 'ora';
+import inquirer from 'inquirer';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export async function startCommand(options) {
+    const spinner = ora('加载配置中...').start();
+    try {
+        const config = await loadConfig({
+            projectId: options.project,
+            token: options.token,
+            dir: options.dir,
+            port: options.port ? parseInt(options.port) : undefined,
+        });
+        if (!config.projectId) {
+            spinner.fail('项目 ID 未设置');
+            console.error(pc.red('请使用 --project 参数或配置文件设置项目 ID'));
+            process.exit(1);
+        }
+        spinner.succeed('配置加载完成');
+        // 检查端口是否可用
+        const portAvailable = await isPortAvailable(config.port);
+        if (!portAvailable) {
+            if (options.daemon) {
+                // 守护进程模式：自动查找可用端口
+                spinner.start('端口被占用，查找可用端口...');
+                config.port = await findAvailablePort(config.port);
+                spinner.succeed(`使用端口: ${config.port}`);
+            }
+            else {
+                // 前台模式：询问用户
+                spinner.stop();
+                const answer = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'useOtherPort',
+                        message: `端口 ${config.port} 已被占用，是否使用其他端口？`,
+                        default: true,
+                    },
+                ]);
+                if (answer.useOtherPort) {
+                    spinner.start('查找可用端口...');
+                    config.port = await findAvailablePort(config.port);
+                    spinner.succeed(`使用端口: ${config.port}`);
+                }
+                else {
+                    console.log(pc.yellow('已取消启动'));
+                    process.exit(0);
+                }
+            }
+        }
+        // 检查是否已有进程在运行
+        const existingPid = await ProcessManager.loadPid(config.projectId);
+        if (existingPid && ProcessManager.isRunning(existingPid)) {
+            spinner.fail('服务已在运行');
+            console.error(pc.red(`项目 ${config.projectId} 的 agent 已在运行 (PID: ${existingPid})`));
+            console.log(pc.yellow(`使用 'playcraft stop --project ${config.projectId}' 停止服务`));
+            process.exit(1);
+        }
+        if (options.daemon) {
+            // 守护进程模式
+            await startDaemon(config);
+        }
+        else {
+            // 前台模式
+            await startForeground(config);
+        }
+    }
+    catch (error) {
+        spinner.fail('启动失败');
+        console.error(pc.red(`错误: ${error.message}`));
+        process.exit(1);
+    }
+}
+async function startDaemon(config) {
+    console.log(pc.cyan('\n🚀 启动 PlayCraft Agent (守护进程模式)...\n'));
+    // 获取当前脚本路径（编译后的 dist/index.js）
+    // 注意：在运行时，__dirname 指向 dist/commands，所以需要回到 dist
+    const scriptPath = path.join(__dirname, '..', 'index.js');
+    // 使用 spawn 启动子进程
+    const child = spawn('node', [scriptPath, 'start'], {
+        detached: true,
+        stdio: 'ignore',
+        env: {
+            ...process.env,
+            PLAYCRAFT_INTERNAL: 'true',
+            PLAYCRAFT_PROJECT_ID: config.projectId,
+            PLAYCRAFT_TOKEN: config.token || '',
+            PLAYCRAFT_PORT: config.port.toString(),
+            PLAYCRAFT_DIR: config.dir,
+            PLAYCRAFT_DAEMON: 'true',
+        },
+    });
+    child.unref();
+    // 等待一下确保进程启动
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    // 检查进程是否还在运行
+    try {
+        if (!child.pid) {
+            throw new Error('无法获取进程 PID');
+        }
+        process.kill(child.pid, 0);
+        await ProcessManager.savePid(config.projectId || 'default', child.pid);
+        console.log(pc.green(`✅ Agent 已在后台启动 (PID: ${child.pid})`));
+        console.log(pc.cyan(`项目 ID: ${config.projectId}`));
+        console.log(pc.cyan(`端口: ${config.port}`));
+        console.log(pc.cyan(`目录: ${config.dir}`));
+        console.log(pc.dim(`\n使用 'playcraft status --project ${config.projectId}' 查看状态`));
+        console.log(pc.dim(`使用 'playcraft logs --project ${config.projectId}' 查看日志\n`));
+    }
+    catch (error) {
+        console.error(pc.red('启动失败：进程已退出'));
+        process.exit(1);
+    }
+}
+async function startForeground(config) {
+    const logger = new Logger(config.projectId || 'default', false);
+    await logger.initialize();
+    console.log(pc.cyan(`\n🚀 PlayCraft Agent 启动中...\n`));
+    console.log(`${pc.bold('项目 ID:')} ${config.projectId || pc.yellow('未设置')}`);
+    console.log(`${pc.bold('目录:')}  ${config.dir}`);
+    console.log(`${pc.bold('端口:')}  ${config.port}\n`);
+    const fsHandler = new FSHandler(config);
+    const app = createServer(config, fsHandler);
+    const server = http.createServer(app);
+    // Connection status indicator
+    let lastConnectionCount = 0;
+    const socketServer = new SocketServer(server, config, async (count) => {
+        if (count > lastConnectionCount) {
+            const message = `✅ 编辑器已连接 (共 ${count} 个连接)`;
+            await logger.info(message);
+            console.log(pc.green(message));
+        }
+        else if (count < lastConnectionCount) {
+            const message = count === 0
+                ? '⚠️  编辑器已断开连接，等待重新连接...'
+                : `⚠️  连接数减少 (剩余 ${count} 个连接)`;
+            await logger.info(message);
+            console.log(pc.yellow(message));
+        }
+        lastConnectionCount = count;
+    });
+    const watcher = new Watcher(config, async (filePath, type) => {
+        const message = `[${type.toUpperCase()}] ${filePath}`;
+        await logger.info(message);
+        socketServer.notifyFileChange(filePath, type);
+    });
+    server.listen(config.port, async () => {
+        await logger.info(`Local server running at http://localhost:${config.port}`);
+        console.log(pc.green(`✅ 本地服务运行在 http://localhost:${config.port}`));
+        console.log(pc.dim('等待编辑器连接...\n'));
+    });
+    // 优雅关闭
+    const shutdown = async () => {
+        console.log(pc.yellow('\n正在关闭 agent...'));
+        // Set a timeout to force exit if graceful shutdown fails
+        const forceExitTimeout = setTimeout(() => {
+            console.log(pc.red('强制退出...'));
+            process.exit(1);
+        }, 3000); // 3 seconds timeout
+        try {
+            // Close watcher
+            await watcher.close();
+            // Close WebSocket connections
+            socketServer.destroy();
+            // Close HTTP server
+            await new Promise((resolve) => {
+                server.close(() => {
+                    resolve();
+                });
+                // Force close if it takes too long
+                setTimeout(() => {
+                    resolve();
+                }, 1000);
+            });
+            // Close logger
+            await logger.close();
+            clearTimeout(forceExitTimeout);
+            console.log(pc.green('✅ Agent 已关闭'));
+            process.exit(0);
+        }
+        catch (error) {
+            clearTimeout(forceExitTimeout);
+            console.error(pc.red('关闭时出错:'), error);
+            process.exit(1);
+        }
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+// 内部启动函数（用于守护进程）
+export async function startInternal() {
+    const projectId = process.env.PLAYCRAFT_PROJECT_ID;
+    const token = process.env.PLAYCRAFT_TOKEN;
+    const port = parseInt(process.env.PLAYCRAFT_PORT || '2468');
+    const dir = process.env.PLAYCRAFT_DIR || process.cwd();
+    const isDaemon = process.env.PLAYCRAFT_DAEMON === 'true';
+    if (!projectId) {
+        console.error('PLAYCRAFT_PROJECT_ID 环境变量未设置');
+        process.exit(1);
+    }
+    const config = {
+        projectId,
+        token,
+        dir,
+        port,
+    };
+    const logger = new Logger(config.projectId || 'default', isDaemon);
+    await logger.initialize();
+    await logger.info(`Starting PlayCraft Agent for project: ${config.projectId || 'default'}`);
+    await logger.info(`Directory: ${config.dir}`);
+    await logger.info(`Port: ${config.port}`);
+    const fsHandler = new FSHandler(config);
+    const app = createServer(config, fsHandler);
+    const server = http.createServer(app);
+    // Connection status tracking for daemon mode
+    let lastConnectionCount = 0;
+    const socketServer = new SocketServer(server, config, async (count) => {
+        if (count > lastConnectionCount) {
+            await logger.info(`Editor connected (${count} connection(s))`);
+        }
+        else if (count < lastConnectionCount) {
+            await logger.info(count === 0 ? 'Editor disconnected' : `Connection decreased (${count} remaining)`);
+        }
+        lastConnectionCount = count;
+    });
+    const watcher = new Watcher(config, async (filePath, type) => {
+        await logger.info(`[${type.toUpperCase()}] ${filePath}`);
+        socketServer.notifyFileChange(filePath, type);
+    });
+    server.listen(config.port, async () => {
+        await logger.info(`Local server running at http://localhost:${config.port}`);
+    });
+    // 保存 PID
+    await ProcessManager.savePid(config.projectId || 'default', process.pid);
+    // 优雅关闭
+    const shutdown = async () => {
+        await logger.info('Shutting down agent...');
+        // Set a timeout to force exit
+        const forceExitTimeout = setTimeout(() => {
+            process.exit(1);
+        }, 3000);
+        try {
+            // Close watcher
+            await watcher.close();
+            // Close WebSocket connections
+            socketServer.destroy();
+            // Close HTTP server
+            await new Promise((resolve) => {
+                server.close(() => {
+                    resolve();
+                });
+                setTimeout(() => {
+                    resolve();
+                }, 1000);
+            });
+            // Remove PID file
+            await ProcessManager.removePid(config.projectId || 'default');
+            // Close logger
+            await logger.close();
+            clearTimeout(forceExitTimeout);
+            process.exit(0);
+        }
+        catch (error) {
+            clearTimeout(forceExitTimeout);
+            await logger.error(`Error during shutdown: ${error}`);
+            process.exit(1);
+        }
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}