@playcraft/cli 0.0.11 → 0.0.13

package/dist/config.js

@@ -8,6 +8,7 @@ export const ConfigSchema = z.object({
     dir: z.string().default(process.cwd()),
     port: z.number().default(2468),
     url: z.string().optional(), // Cloud API URL
+    mode: z.enum(['full-local', 'hybrid']).default('full-local'),
 });
 const explorer = cosmiconfig('playcraft', {
     searchPlaces: ['playcraft.config.json', 'playcraft.agent.config.json'],
@@ -24,6 +25,7 @@ export async function loadConfig(cliOptions) {
         projectId: cliOptions.projectId || process.env.PLAYCRAFT_PROJECT_ID || agentConfig.projectId,
         token: cliOptions.token || process.env.PLAYCRAFT_TOKEN || agentConfig.token,
         port: cliOptions.port || (process.env.PLAYCRAFT_PORT ? parseInt(process.env.PLAYCRAFT_PORT) : undefined) || agentConfig.port,
+        mode: cliOptions.mode || process.env.PLAYCRAFT_MODE || agentConfig.mode,
     });
     // Resolve absolute path for dir
     config.dir = path.resolve(process.cwd(), config.dir);

package/dist/fs-handler.js

@@ -80,4 +80,25 @@ export class FSHandler {
             throw error;
         }
     }
+    async writeFile(relativePath, content) {
+        if (!this.isSafePath(relativePath)) {
+            throw new Error('Access denied: path is outside of the project directory');
+        }
+        const fullPath = path.join(this.config.dir, relativePath);
+        const dir = path.dirname(fullPath);
+        await fs.mkdir(dir, { recursive: true });
+        if (typeof content === 'string') {
+            await fs.writeFile(fullPath, content, 'utf-8');
+        }
+        else {
+            await fs.writeFile(fullPath, content);
+        }
+    }
+    async deleteFile(relativePath) {
+        if (!this.isSafePath(relativePath)) {
+            throw new Error('Access denied: path is outside of the project directory');
+        }
+        const fullPath = path.join(this.config.dir, relativePath);
+        await fs.unlink(fullPath);
+    }
 }

package/dist/index.js

@@ -10,6 +10,10 @@ import { statusCommand } from './commands/status.js';
 import { logsCommand } from './commands/logs.js';
 import { configCommand } from './commands/config.js';
 import { buildCommand } from './commands/build.js';
+import { upgradeCommand } from './commands/upgrade.js';
+import { checkForUpdates } from './utils/version-checker.js';
+import { syncCommand } from './commands/sync.js';
+import { fixIdsCommand } from './commands/fix-ids.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const packageJson = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
@@ -18,6 +22,11 @@ program
     .name('playcraft')
     .description('PlayCraft Local Dev Agent - 本地开发助手')
     .version(packageJson.version);
+// 版本检查（非阻塞，后台执行）
+// 只在非 upgrade 命令时检查，避免重复提示
+if (!process.argv.includes('upgrade')) {
+    checkForUpdates(packageJson);
+}
 // init 命令
 program
     .command('init')
@@ -34,6 +43,7 @@ program
     .option('-t, --token <token>', '认证令牌')
     .option('-d, --dir <path>', '监听目录', process.cwd())
     .option('--port <port>', '服务端口', '2468')
+    .option('--mode <mode>', '运行模式: full-local(默认) | hybrid', 'full-local')
     .option('--daemon', '守护进程模式（后台运行）')
     .action(async (options) => {
     // 检查是否是内部调用（守护进程）
@@ -82,6 +92,33 @@ program
     .action(async (action, options) => {
     await configCommand(action, options);
 });
+// sync 命令（hybrid 模式下本地/云端双向同步）
+program
+    .command('sync')
+    .description('本地/云端数据同步（hybrid 模式）')
+    .argument('<action>', 'push | pull | status')
+    .option('--force', '强制同步')
+    .action(async (action, options) => {
+    if (action !== 'push' && action !== 'pull' && action !== 'status') {
+        console.error('sync action must be push, pull or status');
+        process.exit(1);
+    }
+    await syncCommand(action, options);
+});
+// fix-ids 命令：修复已导入项目的 ID 映射
+program
+    .command('fix-ids')
+    .description('修复已导入项目的 ID 映射（PlayCanvas ID → PlayCraft numericId）')
+    .argument('<project-id>', '项目 ID（numericId 或 UUID）')
+    .option('--api-url <url>', '后端 API 地址', process.env.BACKEND_API_URL || 'http://localhost:3001')
+    .option('--token <token>', '认证令牌（可选）')
+    .action(async (projectId, options) => {
+    await fixIdsCommand({
+        projectId,
+        apiUrl: options.apiUrl,
+        token: options.token,
+    });
+});
 // build 命令 - 完整流程（阶段1 + 阶段2）
 program
     .command('build')
@@ -92,6 +129,8 @@ program
     .option('-o, --output <path>', '输出目录', './dist')
     .option('-c, --config <file>', '配置文件路径')
     .option('-s, --scenes <scenes>', '选择场景（逗号分隔），例如: MainMenu,Gameplay')
+    .option('--clean', '构建前清理旧的输出目录（默认启用）', true)
+    .option('--no-clean', '跳过清理旧的输出目录')
     .option('--compress', '压缩引擎代码')
     .option('--analyze', '生成打包分析报告')
     .option('--replace-ammo', '检测到 Ammo 时自动替换为 p2 或 cannon')
@@ -157,6 +196,7 @@ program
     .option('--compress-models', '压缩 3D 模型（默认根据平台配置）')
     .option('--no-compress-models', '禁用模型压缩')
     .option('--model-compression <method>', '模型压缩方法 (draco|meshopt)', 'draco')
+    .option('--esm-mode <mode>', 'ESM 模块处理模式 (auto|enabled|disabled)', 'auto')
     .action(async (projectPath, options) => {
     await buildCommand(projectPath, {
         ...options,
@@ -172,6 +212,8 @@ program
     .option('-f, --format <format>', '输出格式 (html|zip)', 'html')
     .option('-o, --output <path>', '输出目录', './dist')
     .option('-c, --config <file>', '配置文件路径')
+    .option('--clean', '构建前清理旧的输出目录（默认不清理，使用覆盖模式）')
+    .option('--no-clean', '使用覆盖模式（默认行为）')
     .option('--compress', '压缩引擎代码')
     .option('--analyze', '生成打包分析报告')
     .option('--replace-ammo', '检测到 Ammo 时自动替换为 p2 或 cannon')
@@ -190,6 +232,7 @@ program
     .option('--compress-models', '压缩 3D 模型（默认根据平台配置）')
     .option('--no-compress-models', '禁用模型压缩')
     .option('--model-compression <method>', '模型压缩方法 (draco|meshopt)', 'draco')
+    .option('--esm-mode <mode>', 'ESM 模块处理模式 (auto|enabled|disabled)', 'auto')
     .action(async (baseBuildDir, options) => {
     await buildCommand(baseBuildDir, {
         ...options,
@@ -205,4 +248,12 @@ program
     const { inspectCommand } = await import('./commands/inspect.js');
     await inspectCommand(projectPath);
 });
+// upgrade 命令 - 检查并更新 CLI
+program
+    .command('upgrade')
+    .description('检查并更新 CLI 到最新版本')
+    .option('--check-only', '仅检查版本，不更新')
+    .action(async (options) => {
+    await upgradeCommand(options);
+});
 program.parse(process.argv);

package/dist/server.js

@@ -73,6 +73,34 @@ export function createServer(config, fsHandler) {
             res.status(500).json({ error: error.message });
         }
     });
+    // Write file
+    app.post('/file', async (req, res) => {
+        const { path: filePath, content } = req.body ?? {};
+        if (!filePath) {
+            return res.status(400).json({ error: 'Missing path parameter' });
+        }
+        try {
+            await fsHandler.writeFile(filePath, content ?? '');
+            res.json({ success: true, path: filePath });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    // Delete file
+    app.delete('/file', async (req, res) => {
+        const filePath = req.query.path;
+        if (!filePath) {
+            return res.status(400).json({ error: 'Missing path parameter' });
+        }
+        try {
+            await fsHandler.deleteFile(filePath);
+            res.json({ success: true });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
     // Batch get files
     app.post('/files', async (req, res) => {
         const { paths } = req.body;

package/dist/socket.js

@@ -1,21 +1,73 @@
 import { WebSocketServer, WebSocket } from 'ws';
+/** Match file path against glob pattern. Supports * (segment) and ** (any path). */
+function matchPattern(filePath, pattern) {
+    const pathNorm = filePath.replace(/\\/g, '/');
+    const parts = pathNorm.split('/').filter(Boolean);
+    const patternParts = pattern.replace(/\\/g, '/').split('/').filter(Boolean);
+    let pi = 0;
+    let fi = 0;
+    while (pi < patternParts.length && fi < parts.length) {
+        const p = patternParts[pi];
+        if (p === '**') {
+            pi++;
+            if (pi === patternParts.length)
+                return true;
+            while (fi < parts.length) {
+                if (matchRest(parts, patternParts, fi, pi))
+                    return true;
+                fi++;
+            }
+            return false;
+        }
+        if (p !== '*' && p !== parts[fi])
+            return false;
+        pi++;
+        fi++;
+    }
+    if (pi < patternParts.length && patternParts[pi] === '**')
+        pi++;
+    return pi === patternParts.length && fi === parts.length;
+}
+function matchRest(parts, patternParts, fi, pi) {
+    while (pi < patternParts.length && fi < parts.length) {
+        const p = patternParts[pi];
+        if (p === '**') {
+            pi++;
+            if (pi === patternParts.length)
+                return true;
+            while (fi < parts.length) {
+                if (matchRest(parts, patternParts, fi, pi))
+                    return true;
+                fi++;
+            }
+            return false;
+        }
+        if (p !== '*' && p !== parts[fi])
+            return false;
+        pi++;
+        fi++;
+    }
+    if (pi < patternParts.length && patternParts[pi] === '**')
+        pi++;
+    return pi === patternParts.length && fi === parts.length;
+}
 export class SocketServer {
     config;
     wss;
-    clients = new Set();
+    clients = new Map();
     pingInterval = null;
     onConnectionChange;
     constructor(server, config, onConnectionChange) {
         this.config = config;
-        this.wss = new WebSocketServer({ server });
+        // 注意：必须显式指定 path='/'，避免拦截 /realtime、/messenger 等其他 WebSocket 服务
+        this.wss = new WebSocketServer({ server, path: '/' });
         this.onConnectionChange = onConnectionChange;
         this.wss.on('connection', (ws) => {
-            this.clients.add(ws);
+            this.clients.set(ws, { patterns: ['**/*'] });
             // Notify connection change
             if (this.onConnectionChange) {
                 this.onConnectionChange(this.clients.size);
             }
-            // Handle incoming messages
             ws.on('message', (data) => {
                 try {
                     const message = JSON.parse(data.toString());
@@ -27,12 +79,10 @@ export class SocketServer {
             });
             ws.on('close', () => {
                 this.clients.delete(ws);
-                // Notify connection change
                 if (this.onConnectionChange) {
                     this.onConnectionChange(this.clients.size);
                 }
             });
-            // Send initial hello
             ws.send(JSON.stringify({
                 type: 'hello',
                 payload: {
@@ -40,10 +90,8 @@ export class SocketServer {
                     version: '1.0.0'
                 }
             }));
-            // Send connection status
             this.broadcast('connection_status', { connected: true });
         });
-        // Start ping interval
         this.startPingInterval();
     }
     handleMessage(ws, message) {
@@ -51,14 +99,18 @@ export class SocketServer {
             case 'ping':
                 ws.send(JSON.stringify({ type: 'pong', payload: message.payload }));
                 break;
-            case 'subscribe':
-                // Store subscription patterns for this client (simplified implementation)
-                // In a full implementation, we would filter file change notifications
+            case 'subscribe': {
+                const patterns = message.payload?.patterns || ['**/*'];
+                const info = this.clients.get(ws);
+                if (info) {
+                    info.patterns = Array.isArray(patterns) ? patterns : [patterns];
+                }
                 ws.send(JSON.stringify({
                     type: 'subscribed',
-                    payload: { patterns: message.payload?.patterns || [] }
+                    payload: { patterns: info?.patterns ?? patterns }
                 }));
                 break;
+            }
         }
     }
     startPingInterval() {
@@ -66,7 +118,7 @@ export class SocketServer {
             clearInterval(this.pingInterval);
         }
         this.pingInterval = setInterval(() => {
-            for (const client of this.clients) {
+            for (const client of this.clients.keys()) {
                 if (client.readyState === WebSocket.OPEN) {
                     try {
                         client.send(JSON.stringify({ type: 'ping', payload: Date.now() }));
@@ -83,8 +135,7 @@ export class SocketServer {
             clearInterval(this.pingInterval);
             this.pingInterval = null;
         }
-        // Close all WebSocket connections
-        for (const client of this.clients) {
+        for (const client of this.clients.keys()) {
             try {
                 client.close();
             }
@@ -93,23 +144,31 @@ export class SocketServer {
             }
         }
         this.clients.clear();
-        // Close WebSocket server
         this.wss.close();
     }
     broadcast(type, payload) {
         const message = JSON.stringify({ type, payload });
-        for (const client of this.clients) {
+        for (const client of this.clients.keys()) {
             if (client.readyState === WebSocket.OPEN) {
                 client.send(message);
             }
         }
     }
-    notifyFileChange(path, changeType) {
-        this.broadcast('file_changed', {
-            path,
+    notifyFileChange(filePath, changeType) {
+        const payload = {
+            path: filePath,
             changeType,
             timestamp: new Date().toISOString()
-        });
+        };
+        const message = JSON.stringify({ type: 'file_changed', payload });
+        for (const [ws, info] of this.clients) {
+            if (ws.readyState !== WebSocket.OPEN)
+                continue;
+            const matches = info.patterns.some((pattern) => matchPattern(filePath, pattern));
+            if (matches) {
+                ws.send(message);
+            }
+        }
     }
     getConnectionCount() {
         return this.clients.size;

package/dist/sync/sync-engine.js

@@ -0,0 +1,213 @@
+/**
+ * SyncEngine – CLI entry point for sync push/pull/status.
+ * Uses CloudConnectionManager and SyncManager to perform sync operations.
+ */
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import pc from 'picocolors';
+import ora from 'ora';
+import { loadConfig } from '../config.js';
+import { CloudConnectionManager } from '../agent/cloud-connection.js';
+import { SyncManager } from './sync-manager.js';
+const IGNORE_PATTERNS = [
+    'node_modules',
+    '.git',
+    'dist',
+    'playcraft.agent.config.json',
+    '.DS_Store',
+];
+function shouldSyncFile(relativePath) {
+    const normalized = relativePath.replace(/\\/g, '/');
+    if (IGNORE_PATTERNS.some((p) => normalized.includes(p)))
+        return false;
+    if (normalized.startsWith('.'))
+        return false;
+    return true;
+}
+async function* walkFiles(dir, baseDir) {
+    let entries;
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const ent of entries) {
+        const full = path.join(dir, ent.name);
+        const rel = path.relative(baseDir, full);
+        if (!shouldSyncFile(rel))
+            continue;
+        if (ent.isFile()) {
+            yield rel;
+        }
+        else if (ent.isDirectory()) {
+            yield* walkFiles(full, baseDir);
+        }
+    }
+}
+export class SyncEngine {
+    options;
+    cloudConnection = null;
+    syncManager = null;
+    constructor(options) {
+        this.options = options;
+    }
+    async ensureConnected() {
+        if (this.cloudConnection?.isConnected && this.syncManager) {
+            return { connection: this.cloudConnection, syncManager: this.syncManager };
+        }
+        const connection = new CloudConnectionManager({
+            url: this.options.url,
+            token: this.options.token,
+            projectId: this.options.projectId,
+        });
+        await connection.connect();
+        const syncManager = new SyncManager({
+            cloudConnection: connection,
+            projectDir: this.options.projectDir,
+        });
+        this.cloudConnection = connection;
+        this.syncManager = syncManager;
+        return { connection, syncManager };
+    }
+    async push(options) {
+        const spinner = ora('连接云端...').start();
+        try {
+            const { syncManager } = await this.ensureConnected();
+            spinner.succeed('已连接');
+            const files = [];
+            for await (const rel of walkFiles(this.options.projectDir, this.options.projectDir)) {
+                files.push(rel);
+            }
+            const toUpload = files.filter((f) => f.endsWith('.json') || f.includes('manifest') || f.startsWith('scenes/') || f.startsWith('assets/'));
+            if (toUpload.length === 0) {
+                toUpload.push(...files.slice(0, 50));
+            }
+            if (toUpload.length === 0) {
+                console.log(pc.yellow('没有需要同步的文件'));
+                return;
+            }
+            console.log(pc.cyan(`\n准备推送 ${toUpload.length} 个文件\n`));
+            let ok = 0;
+            let fail = 0;
+            for (const file of toUpload) {
+                const result = await syncManager.upload(file);
+                if (result.success) {
+                    ok++;
+                    console.log(pc.green(`  ↑ ${file}`));
+                }
+                else {
+                    fail++;
+                    console.log(pc.red(`  ✗ ${file}: ${result.error}`));
+                }
+            }
+            console.log(pc.cyan(`\n完成: ${ok} 成功, ${fail} 失败`));
+        }
+        catch (err) {
+            spinner.fail('连接失败');
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(pc.red(msg));
+            process.exit(1);
+        }
+        finally {
+            await this.cloudConnection?.disconnect();
+        }
+    }
+    async pull(options) {
+        const spinner = ora('连接云端...').start();
+        try {
+            const { syncManager } = await this.ensureConnected();
+            spinner.succeed('已连接');
+            const pending = syncManager.getPendingDownloads();
+            if (pending.length > 0) {
+                console.log(pc.cyan(`\n准备拉取 ${pending.length} 个文件\n`));
+                let ok = 0;
+                let fail = 0;
+                for (const file of pending) {
+                    const result = await syncManager.download(file);
+                    if (result.success) {
+                        ok++;
+                        console.log(pc.green(`  ↓ ${file}`));
+                    }
+                    else {
+                        fail++;
+                        console.log(pc.red(`  ✗ ${file}: ${result.error}`));
+                    }
+                }
+                console.log(pc.cyan(`\n完成: ${ok} 成功, ${fail} 失败`));
+                return;
+            }
+            try {
+                const state = await this.cloudConnection.request('GET', '/api/sync/state');
+                const paths = state?.files?.map((f) => f.path) ?? [];
+                if (paths.length === 0) {
+                    console.log(pc.yellow('云端暂无文件列表，或 API 未实现'));
+                    return;
+                }
+                console.log(pc.cyan(`\n准备拉取 ${paths.length} 个文件\n`));
+                let ok = 0;
+                let fail = 0;
+                for (const file of paths) {
+                    const result = await syncManager.download(file);
+                    if (result.success) {
+                        ok++;
+                        console.log(pc.green(`  ↓ ${file}`));
+                    }
+                    else {
+                        fail++;
+                        console.log(pc.red(`  ✗ ${file}: ${result.error}`));
+                    }
+                }
+                console.log(pc.cyan(`\n完成: ${ok} 成功, ${fail} 失败`));
+            }
+            catch (e) {
+                console.log(pc.yellow('拉取需要云端 /api/sync/state 支持'));
+            }
+        }
+        catch (err) {
+            spinner.fail('连接失败');
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(pc.red(msg));
+            process.exit(1);
+        }
+        finally {
+            await this.cloudConnection?.disconnect();
+        }
+    }
+    async status() {
+        const spinner = ora('连接云端...').start();
+        try {
+            const { connection, syncManager } = await this.ensureConnected();
+            spinner.succeed('已连接');
+            const state = connection.connectionState;
+            const pendingUp = syncManager.getPendingUploads();
+            const pendingDown = syncManager.getPendingDownloads();
+            console.log(pc.cyan('\n同步状态\n'));
+            console.log(`  连接: ${state === 'connected' ? pc.green(state) : pc.yellow(state)}`);
+            console.log(`  待上传: ${pendingUp.length}`);
+            console.log(`  待下载: ${pendingDown.length}`);
+            console.log();
+        }
+        catch (err) {
+            spinner.fail('连接失败');
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(pc.red(msg));
+            process.exit(1);
+        }
+        finally {
+            await this.cloudConnection?.disconnect();
+        }
+    }
+}
+export async function createSyncEngineFromConfig() {
+    const config = await loadConfig({});
+    if (!config.url || !config.token || !config.projectId) {
+        throw new Error('Sync 需要配置 url、token 和 projectId（hybrid 模式）');
+    }
+    return new SyncEngine({
+        url: config.url,
+        token: config.token,
+        projectId: config.projectId,
+        projectDir: config.dir,
+    });
+}

package/dist/sync/sync-manager.js

@@ -0,0 +1,62 @@
+/**
+ * SyncManager – manages local/cloud file sync for Hybrid mode.
+ * MVP: upload/download stubs; full implementation in Week 3-4.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export class SyncManager {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async upload(filePath) {
+        const fullPath = path.join(this.options.projectDir, filePath);
+        try {
+            const content = await fs.readFile(fullPath);
+            const base64 = content.toString('base64');
+            await this.options.cloudConnection.request('POST', '/api/sync/upload', {
+                path: filePath,
+                data: base64,
+                compressed: false,
+            });
+            return { success: true, path: filePath, direction: 'up', timestamp: new Date() };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                success: false,
+                path: filePath,
+                direction: 'up',
+                timestamp: new Date(),
+                error: message,
+            };
+        }
+    }
+    async download(filePath) {
+        try {
+            const content = await this.options.cloudConnection.request('GET', `/api/sync/download?path=${encodeURIComponent(filePath)}`);
+            const base64 = typeof content === 'object' && content && 'data' in content ? content.data : String(content);
+            const fullPath = path.join(this.options.projectDir, filePath);
+            const dir = path.dirname(fullPath);
+            await fs.mkdir(dir, { recursive: true });
+            await fs.writeFile(fullPath, Buffer.from(base64, 'base64'));
+            return { success: true, path: filePath, direction: 'down', timestamp: new Date() };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                success: false,
+                path: filePath,
+                direction: 'down',
+                timestamp: new Date(),
+                error: message,
+            };
+        }
+    }
+    getPendingUploads() {
+        return [];
+    }
+    getPendingDownloads() {
+        return [];
+    }
+}