@playcraft/cli 0.0.15 → 0.0.18

package/dist/agent/agent.js

@@ -1,4 +1,5 @@
 import http from 'node:http';
+import { URL } from 'node:url';
 import path from 'node:path';
 import os from 'node:os';
 import pc from 'picocolors';
@@ -39,7 +40,12 @@ export class PlayCraftAgent {
             console.log(`${pc.bold('端口:')}  ${this.config.port}\n`);
         }
         const fsHandler = new FSHandler(this.config);
-        const app = createServer(this.config, fsHandler);
+        // 延迟绑定：watcher 创建后才绑定实际函数
+        let suppressFileChange;
+        const onFileWritten = (relativePath) => {
+            suppressFileChange?.(relativePath);
+        };
+        const app = createServer(this.config, fsHandler, { onFileWritten });
         const server = http.createServer(app);
         let messenger;
         let realtime;
@@ -73,6 +79,7 @@ export class PlayCraftAgent {
                 onFileChange: (invalidate) => {
                     invalidateFsCache = invalidate;
                 },
+                onFileWritten,
             });
             app.use('/api', localBackend.router);
             // 3) /emit (internal emit compatibility)
@@ -146,6 +153,50 @@ export class PlayCraftAgent {
             }
             lastConnectionCount = count;
         });
+        // 🔧 统一的 WebSocket upgrade handler：
+        // SocketServer 使用 noServer 模式，需要手动处理 upgrade
+        // 在 full-local 模式下还有 Messenger 和 Realtime 的 WebSocketServer
+        {
+            const socketWss = socketServer.getWss();
+            if (this.mode === 'full-local') {
+                // 移除 Messenger 和 Realtime 自动注册的所有 upgrade listener
+                const priorListeners = server.listenerCount('upgrade');
+                server.removeAllListeners('upgrade');
+                console.log(`[agent] 🔧 Removed ${priorListeners} auto-registered upgrade listeners`);
+                const messengerWss = messenger?.wss;
+                const realtimeWss = realtime?.wss;
+                server.on('upgrade', (req, socket, head) => {
+                    const pathname = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`).pathname;
+                    console.log(`[agent] 🔌 WebSocket upgrade request: pathname=${pathname}`);
+                    if (pathname === '/messenger' && messengerWss) {
+                        messengerWss.handleUpgrade(req, socket, head, (ws) => {
+                            messengerWss.emit('connection', ws, req);
+                        });
+                    }
+                    else if (pathname === '/realtime' && realtimeWss) {
+                        realtimeWss.handleUpgrade(req, socket, head, (ws) => {
+                            realtimeWss.emit('connection', ws, req);
+                        });
+                    }
+                    else {
+                        console.log(`[agent] ✅ Routing to SocketServer (path=${pathname})`);
+                        socketWss.handleUpgrade(req, socket, head, (ws) => {
+                            socketWss.emit('connection', ws, req);
+                        });
+                    }
+                });
+            }
+            else {
+                // 非 full-local 模式：只有 SocketServer 需要 upgrade handler
+                server.on('upgrade', (req, socket, head) => {
+                    const pathname = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`).pathname;
+                    console.log(`[agent] 🔌 WebSocket upgrade request (non-full-local): pathname=${pathname}`);
+                    socketWss.handleUpgrade(req, socket, head, (ws) => {
+                        socketWss.emit('connection', ws, req);
+                    });
+                });
+            }
+        }
         const watcher = new Watcher(this.config, async (filePath, type) => {
             await logger.info(`[${type.toUpperCase()}] ${filePath}`);
             invalidateFsCache?.();
@@ -154,6 +205,8 @@ export class PlayCraftAgent {
                 void syncManager.upload(filePath);
             }
         });
+        // 绑定延迟引用：让 server/local-backend 写文件后能抑制 watcher 回弹
+        suppressFileChange = (relativePath) => watcher.suppressFile(relativePath);
         await new Promise((resolve) => {
             server.listen(this.config.port, async () => {
                 await logger.info(`Local server running at http://localhost:${this.config.port}`);

package/dist/agent/fs-backend.js

@@ -1,14 +1,49 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
+/** 文件扩展名 → 资产类型映射 */
+const EXT_TO_TYPE = {
+    '.js': 'script',
+    '.mjs': 'script',
+    '.ts': 'script',
+    '.json': 'json',
+    '.png': 'texture',
+    '.jpg': 'texture',
+    '.jpeg': 'texture',
+    '.webp': 'texture',
+    '.hdr': 'texture',
+    '.gif': 'texture',
+    '.glb': 'container',
+    '.gltf': 'container',
+    '.fbx': 'container',
+    '.mp3': 'audio',
+    '.wav': 'audio',
+    '.ogg': 'audio',
+    '.css': 'css',
+    '.html': 'html',
+    '.txt': 'text',
+    '.wasm': 'wasm',
+    '.ttf': 'font',
+    '.woff': 'font',
+    '.woff2': 'font',
+};
 /**
  * File-system backed data source for local development.
  * Reads project data from manifest.json and scene/asset files.
  * Supports both PlayCraft and PlayCanvas project formats.
+ *
+ * Also reads assets/assets.json for full asset data (if exists).
+ * Additionally scans the filesystem for undeclared files in assets/ directory.
  */
 export class FileSystemBackend {
     projectDir;
     manifestCache = null;
     manifestMtime = 0;
+    assetsJsonCache = null;
+    assetsJsonMtime = 0;
+    /** 用于给新发现的文件生成唯一 ID（从 90000000 开始，避免与 numericId 冲突） */
+    nextAutoId = 90000000;
+    /** 缓存已自动生成的 ID（filename → id），确保同一文件在多次调用间 ID 一致 */
+    autoIdMap = new Map();
     constructor(projectDir) {
         this.projectDir = projectDir;
     }
@@ -33,6 +68,28 @@ export class FileSystemBackend {
             throw e;
         }
     }
+    /**
+     * Read and parse assets/assets.json (with cache).
+     * This file contains full asset data in PlayCanvas format.
+     */
+    async getAssetsJson() {
+        const assetsPath = path.join(this.projectDir, 'assets', 'assets.json');
+        try {
+            const stat = await fs.stat(assetsPath);
+            if (this.assetsJsonCache && stat.mtimeMs === this.assetsJsonMtime) {
+                return this.assetsJsonCache;
+            }
+            const content = await fs.readFile(assetsPath, 'utf-8');
+            this.assetsJsonCache = JSON.parse(content);
+            this.assetsJsonMtime = stat.mtimeMs;
+            return this.assetsJsonCache;
+        }
+        catch (e) {
+            if (e?.code === 'ENOENT')
+                return null;
+            throw e;
+        }
+    }
     /**
      * Detect project format from manifest.
      */
@@ -43,31 +100,254 @@ export class FileSystemBackend {
         return 'playcanvas';
     }
     /**
-     * Get all assets from manifest.
+     * Get all assets from manifest.json + assets/assets.json (merged).
+     *
+     * Strategy (matches cloud mode in local-repo.service.ts):
+     * - When assets.json exists: use it as PRIMARY data source (has full data: file, data, preload, source, etc.)
+     *   and only use manifest.json for treePath/path enrichment.
+     * - When assets.json is absent: fall back to manifest.json only.
      */
     async getAssets() {
         const manifest = await this.getManifest();
+        const assetsJson = await this.getAssetsJson();
+        let resultAssets;
+        if (assetsJson && Object.keys(assetsJson).length > 0) {
+            // assets.json exists — use it as primary source (same as cloud mode)
+            resultAssets = this.mergeAssetsJsonPrimary(manifest, assetsJson);
+        }
+        else {
+            // No assets.json — fall back to manifest only
+            resultAssets = this.getAssetsFromManifestOnly(manifest);
+        }
+        // Scan filesystem for undeclared files in assets/ directory
+        try {
+            const discovered = await this.scanUndeclaredFiles(resultAssets);
+            if (discovered.length > 0) {
+                console.log(`[fs-backend] 📂 Discovered ${discovered.length} undeclared files on disk`);
+                resultAssets.push(...discovered);
+            }
+        }
+        catch (err) {
+            console.warn('[fs-backend] ⚠️ Failed to scan for undeclared files:', err);
+        }
+        return resultAssets;
+    }
+    /**
+     * Primary strategy: assets.json is the main data source.
+     * Manifest is only used for treePath / path enrichment.
+     * This matches cloud mode (local-repo.service.ts readAssetsFromManifest).
+     */
+    mergeAssetsJsonPrimary(manifest, assetsJson) {
+        // Build treePath/path maps from manifest
+        const treePathMap = new Map();
+        const manifestPathMap = new Map();
+        const manifestAssetsList = [];
+        if (manifest?.assets) {
+            const rawAssets = Array.isArray(manifest.assets) ? manifest.assets : Object.values(manifest.assets);
+            for (const a of rawAssets) {
+                if (a.id != null) {
+                    const idStr = String(a.id);
+                    if (a.treePath)
+                        treePathMap.set(idStr, a.treePath);
+                    if (Array.isArray(a.path))
+                        manifestPathMap.set(idStr, a.path);
+                }
+                manifestAssetsList.push(a);
+            }
+        }
+        // Iterate all assets.json entries as primary source
+        const result = [];
+        const seenIds = new Set();
+        for (const [key, asset] of Object.entries(assetsJson)) {
+            if (!asset || typeof asset !== 'object')
+                continue;
+            const idStr = String(asset.id ?? key);
+            seenIds.add(idStr);
+            // Resolve treePath: prefer manifest's treePath, then compute from assets.json path
+            let treePath = treePathMap.get(idStr);
+            if (!treePath) {
+                treePath = this.resolveTreePath(asset, assetsJson) ?? undefined;
+            }
+            result.push({
+                ...asset,
+                id: asset.id ?? (parseInt(key, 10) || key),
+                treePath: treePath || '',
+            });
+        }
+        // Also include manifest-only assets (those not in assets.json, e.g. auto-discovered by previous runs)
+        for (const a of manifestAssetsList) {
+            if (a.id != null && !seenIds.has(String(a.id))) {
+                result.push(a);
+                seenIds.add(String(a.id));
+            }
+        }
+        return result;
+    }
+    /**
+     * Fallback strategy: only manifest.json available.
+     */
+    getAssetsFromManifestOnly(manifest) {
         if (!manifest)
             return [];
         const format = this.detectFormat(manifest);
         if (format === 'playcraft') {
-            return Array.isArray(manifest.assets) ? manifest.assets : [];
+            return Array.isArray(manifest.assets) ? [...manifest.assets] : [];
         }
-        const assets = manifest.assets;
-        if (typeof assets === 'object' && assets !== null && !Array.isArray(assets)) {
-            return Object.values(assets);
+        else {
+            const assets = manifest.assets;
+            if (typeof assets === 'object' && assets !== null && !Array.isArray(assets)) {
+                return Object.values(assets);
+            }
         }
         return [];
     }
+    /**
+     * 递归扫描 assets/ 目录，发现未声明的文件并生成 asset 条目。
+     * 只扫描能识别类型的文件（脚本、纹理等），忽略 .meta 文件和 assets.json 本身。
+     */
+    async scanUndeclaredFiles(existingAssets) {
+        const assetsDir = path.join(this.projectDir, 'assets');
+        try {
+            await fs.access(assetsDir);
+        }
+        catch {
+            return []; // assets/ 目录不存在
+        }
+        // 构建已知文件名集合（用于去重）
+        const knownFilenames = new Set();
+        for (const asset of existingAssets) {
+            const filename = asset.file?.filename || asset.fileFilename || asset.filename;
+            if (filename) {
+                knownFilenames.add(filename);
+            }
+            // 也记录 name（有些情况 name 就是文件名）
+            if (asset.name && asset.type !== 'folder') {
+                knownFilenames.add(asset.name);
+            }
+        }
+        const discovered = [];
+        await this.walkDir(assetsDir, 'assets', knownFilenames, discovered);
+        return discovered;
+    }
+    /**
+     * 递归遍历目录
+     */
+    async walkDir(dirPath, relativePath, knownFilenames, result) {
+        let entries;
+        try {
+            entries = await fs.readdir(dirPath, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            // 忽略隐藏文件（.meta 等）
+            if (entry.name.startsWith('.'))
+                continue;
+            // 忽略 assets.json
+            if (entry.name === 'assets.json')
+                continue;
+            const entryRelPath = `${relativePath}/${entry.name}`;
+            if (entry.isDirectory()) {
+                await this.walkDir(path.join(dirPath, entry.name), entryRelPath, knownFilenames, result);
+            }
+            else if (entry.isFile()) {
+                const ext = path.extname(entry.name).toLowerCase();
+                const assetType = EXT_TO_TYPE[ext];
+                if (!assetType)
+                    continue; // 无法识别的文件类型，跳过
+                // 检查是否已在已知列表中
+                if (knownFilenames.has(entry.name))
+                    continue;
+                // 生成稳定的 auto ID
+                let autoId;
+                if (this.autoIdMap.has(entryRelPath)) {
+                    autoId = this.autoIdMap.get(entryRelPath);
+                }
+                else {
+                    autoId = this.nextAutoId++;
+                    this.autoIdMap.set(entryRelPath, autoId);
+                }
+                result.push({
+                    id: autoId,
+                    name: entry.name,
+                    type: assetType,
+                    treePath: relativePath,
+                    file: {
+                        filename: entry.name,
+                        size: 0,
+                    },
+                    // 标记为自动发现的资产
+                    _autoDiscovered: true,
+                });
+                knownFilenames.add(entry.name); // 避免同名文件重复
+            }
+        }
+    }
     /**
      * Get a single asset by id or uniqueId (for Realtime).
+     * First tries manifest.json, then falls back to assets/assets.json.
      */
     async getAsset(assetId) {
+        // 1. Try manifest.json first
         const assets = await this.getAssets();
         const idStr = String(assetId);
-        return (assets.find((a) => String(a.id) === idStr ||
+        const fromManifest = assets.find((a) => String(a.id) === idStr ||
             String(a.uniqueId) === idStr ||
-            (a.uniqueId && String(a.uniqueId) === idStr)) ?? null);
+            (a.uniqueId && String(a.uniqueId) === idStr));
+        if (fromManifest) {
+            return fromManifest;
+        }
+        // 2. Fallback to assets/assets.json (PlayCanvas format)
+        const assetsJson = await this.getAssetsJson();
+        if (assetsJson) {
+            // Direct key lookup
+            if (assetsJson[idStr]) {
+                const asset = assetsJson[idStr];
+                // Normalize to include treePath for file path building
+                return this.normalizeAssetFromAssetsJson(asset, idStr, assetsJson);
+            }
+            // Search by id field
+            for (const [key, asset] of Object.entries(assetsJson)) {
+                if (asset && typeof asset === 'object' &&
+                    (String(asset.id) === idStr || String(asset.uniqueId) === idStr)) {
+                    return this.normalizeAssetFromAssetsJson(asset, key, assetsJson);
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Resolve treePath from assets.json path array (folder IDs -> folder names).
+     * Returns e.g. "assets/scripts" or null if no path.
+     */
+    resolveTreePath(asset, assetsJson) {
+        if (!Array.isArray(asset.path) || asset.path.length === 0) {
+            return 'assets';
+        }
+        const pathParts = ['assets'];
+        for (const folderId of asset.path) {
+            const folderKey = String(folderId);
+            const folder = assetsJson[folderKey];
+            if (folder?.type === 'folder' && folder.name) {
+                pathParts.push(folder.name);
+            }
+            else {
+                pathParts.push(folderKey);
+            }
+        }
+        return pathParts.join('/');
+    }
+    /**
+     * Normalize asset from assets.json to include treePath.
+     * assets.json uses path: [folderId, ...] format, need to resolve to treePath.
+     */
+    normalizeAssetFromAssetsJson(asset, id, assetsJson) {
+        if (!asset)
+            return null;
+        const normalized = { ...asset, id };
+        normalized.treePath = this.resolveTreePath(asset, assetsJson);
+        return normalized;
     }
     /**
      * Get all scenes from manifest.
@@ -122,7 +402,9 @@ export class FileSystemBackend {
         const filename = file.filename ?? file.fileFilename;
         if (!filename)
             return null;
-        const relativePath = this.buildAssetFilePath(asset, filename);
+        let relativePath = this.buildAssetFilePath(asset, filename);
+        // Resolve folder IDs in the path to actual folder names
+        relativePath = await this.resolveTreePathIds(relativePath);
         const fullPath = path.join(this.projectDir, relativePath);
         try {
             return await fs.readFile(fullPath, 'utf-8');
@@ -148,11 +430,33 @@ export class FileSystemBackend {
         }
         return path.join('assets', filename);
     }
+    /**
+     * Resolve a treePath string that may contain folder numeric IDs to actual filesystem names.
+     * e.g. "assets/30014288" → "assets/ammo.js" (where 30014288 is a folder asset with name "ammo.js")
+     */
+    async resolveTreePathIds(treePath) {
+        const assets = await this.getAssets();
+        // Build folder ID → name map (only for folder-type assets)
+        const folderMap = new Map();
+        for (const a of assets) {
+            if (a.type === 'folder' && a.id != null && a.name) {
+                folderMap.set(String(a.id), a.name);
+                if (a.numericId != null)
+                    folderMap.set(String(a.numericId), a.name);
+            }
+        }
+        // Split treePath and replace any segment that is a folder ID
+        const segments = treePath.split('/');
+        const resolved = segments.map(seg => folderMap.get(seg) ?? seg);
+        return resolved.join('/');
+    }
     /**
      * Invalidate cache (call when files change).
      */
     invalidateCache() {
         this.manifestCache = null;
         this.manifestMtime = 0;
+        this.assetsJsonCache = null;
+        this.assetsJsonMtime = 0;
     }
 }