unreal-engine-mcp-server 0.3.1 → 0.4.3

package/dist/resources/assets.js

@@ -1,3 +1,4 @@
+import { coerceBoolean, coerceString, interpretStandardResult } from '../utils/result-helpers.js';
 export class AssetResources {
     bridge;
     constructor(bridge) {
@@ -9,10 +10,36 @@ export class AssetResources {
     makeKey(dir, recursive, page) {
         return page !== undefined ? `${dir}::${recursive ? 1 : 0}::${page}` : `${dir}::${recursive ? 1 : 0}`;
     }
+    // Normalize UE content paths:
+    // - Map '/Content' -> '/Game'
+    // - Ensure forward slashes
+    normalizeDir(dir) {
+        try {
+            if (!dir || typeof dir !== 'string')
+                return '/Game';
+            let d = dir.replace(/\\/g, '/');
+            if (!d.startsWith('/'))
+                d = '/' + d;
+            if (d.toLowerCase().startsWith('/content')) {
+                d = '/Game' + d.substring('/Content'.length);
+            }
+            // Collapse multiple slashes
+            d = d.replace(/\/+/g, '/');
+            // Remove trailing slash except root
+            if (d.length > 1)
+                d = d.replace(/\/$/, '');
+            return d;
+        }
+        catch {
+            return '/Game';
+        }
+    }
     async list(dir = '/Game', _recursive = false, limit = 50) {
         // ALWAYS use non-recursive listing to show only immediate children
         // This prevents timeouts and makes navigation clearer
         _recursive = false; // Force non-recursive
+        // Normalize directory first
+        dir = this.normalizeDir(dir);
         // Cache fast-path
         try {
             const key = this.makeKey(dir, false);
@@ -45,7 +72,8 @@ export class AssetResources {
         // Ensure pageSize doesn't exceed safe limit
         const safePageSize = Math.min(pageSize, 50);
         const offset = page * safePageSize;
-        // Check cache for this specific page
+        // Normalize directory and check cache for this specific page
+        dir = this.normalizeDir(dir);
         const cacheKey = this.makeKey(dir, recursive, page);
         const cached = this.cache.get(cacheKey);
         if (cached && (Date.now() - cached.timestamp) < this.ttlMs) {
@@ -91,8 +119,8 @@ export class AssetResources {
         };
     }
     /**
-     * Directory-based listing for paths with too many assets
-     * Shows only immediate children (folders and files) to avoid timeouts
+     * Directory-based listing of immediate children using AssetRegistry.
+     * Returns both subfolders and assets at the given path.
      */
     async listDirectoryOnly(dir, _recursive, limit) {
         // Always return only immediate children to avoid timeout and improve navigation
@@ -101,100 +129,84 @@ export class AssetResources {
 import unreal
 import json
 
-_dir = r"${dir}"
+_dir = r"${this.normalizeDir(dir)}"
 
 try:
-    # ALWAYS non-recursive - get only immediate children
-    all_paths = unreal.EditorAssetLibrary.list_assets(_dir, False, False)
-    
-    # Organize into immediate children only
-    immediate_folders = set()
-    immediate_assets = []
-    
-    for path in all_paths:
-        # Remove the base directory to get relative path
-        relative = path.replace(_dir, '').strip('/')
-        if not relative:
-            continue
-            
-        # Split to check depth
-        parts = relative.split('/')
-        
-        if len(parts) == 1:
-            # This is an immediate child asset
-            immediate_assets.append(path)
-        elif len(parts) > 1:
-            # This indicates a subfolder exists
-            immediate_folders.add(parts[0])
-    
-    result = []
-    
-    # Add folders first
-    for folder in sorted(immediate_folders):
-        result.append({
-            'n': folder,
-            'p': _dir + '/' + folder,
-            'c': 'Folder',
-            'isFolder': True
-        })
-    
-    # Add immediate assets (limit to prevent socket issues)
-    for asset_path in immediate_assets[:min(${limit}, len(immediate_assets))]:
-        name = asset_path.split('/')[-1].split('.')[0]
-        result.append({
-            'n': name,
-            'p': asset_path,
-            'c': 'Asset'
-        })
-    
-    # Always showing immediate children only
-    note = f'Showing immediate children of {_dir} ({len(immediate_folders)} folders, {len(immediate_assets)} files)'
-    
+    ar = unreal.AssetRegistryHelpers.get_asset_registry()
+    # Immediate subfolders
+    sub_paths = ar.get_sub_paths(_dir, False)
+    folders_list = []
+    for p in sub_paths:
+        try:
+            name = p.split('/')[-1]
+            folders_list.append({'n': name, 'p': p})
+        except Exception:
+            pass
+
+    # Immediate assets at this path
+    assets_data = ar.get_assets_by_path(_dir, False)
+    assets = []
+    for a in assets_data[:${limit}]:
+        try:
+            assets.append({
+                'n': str(a.asset_name),
+                'p': str(a.object_path),
+                'c': str(a.asset_class)
+            })
+        except Exception:
+            pass
+
     print("RESULT:" + json.dumps({
-        'success': True, 
-        'assets': result, 
-        'count': len(result),
-        'folders': len(immediate_folders),
-        'files': len(immediate_assets),
-        'note': note
+        'success': True,
+        'path': _dir,
+        'folders': len(folders_list),
+        'files': len(assets),
+        'folders_list': folders_list,
+        'assets': assets
     }))
 except Exception as e:
-    print("RESULT:" + json.dumps({'success': False, 'error': str(e), 'assets': []}))
+    print("RESULT:" + json.dumps({'success': False, 'error': str(e), 'path': _dir}))
 `.trim();
             const resp = await this.bridge.executePython(py);
-            let output = '';
-            if (resp?.LogOutput && Array.isArray(resp.LogOutput)) {
-                output = resp.LogOutput.map((l) => l.Output || '').join('');
-            }
-            else if (typeof resp === 'string') {
-                output = resp;
-            }
-            else {
-                output = JSON.stringify(resp);
-            }
-            const m = output.match(/RESULT:({.*})/);
-            if (m) {
-                try {
-                    const parsed = JSON.parse(m[1]);
-                    if (parsed.success) {
-                        // Transform to standard format
-                        const assets = parsed.assets.map((a) => ({
-                            Name: a.n,
-                            Path: a.p,
-                            Class: a.c,
-                            isFolder: a.isFolder || false
-                        }));
-                        return {
-                            assets,
-                            count: parsed.count,
-                            folders: parsed.folders,
-                            files: parsed.files,
-                            note: parsed.note,
-                            method: 'directory_listing'
-                        };
-                    }
-                }
-                catch { }
+            const interpreted = interpretStandardResult(resp, {
+                successMessage: 'Directory contents retrieved',
+                failureMessage: 'Failed to list directory contents'
+            });
+            if (interpreted.success) {
+                const payload = interpreted.payload;
+                const foldersArr = Array.isArray(payload.folders_list)
+                    ? payload.folders_list.map((f) => ({
+                        Name: coerceString(f?.n) ?? '',
+                        Path: coerceString(f?.p) ?? '',
+                        Class: 'Folder',
+                        isFolder: true
+                    }))
+                    : [];
+                const assetsArr = Array.isArray(payload.assets)
+                    ? payload.assets.map((a) => ({
+                        Name: coerceString(a?.n) ?? '',
+                        Path: coerceString(a?.p) ?? '',
+                        Class: coerceString(a?.c) ?? 'Asset',
+                        isFolder: false
+                    }))
+                    : [];
+                const total = foldersArr.length + assetsArr.length;
+                const summary = {
+                    total,
+                    folders: foldersArr.length,
+                    assets: assetsArr.length
+                };
+                const resolvedPath = coerceString(payload.path) ?? this.normalizeDir(dir);
+                return {
+                    success: true,
+                    path: resolvedPath,
+                    summary,
+                    foldersList: foldersArr,
+                    assets: assetsArr,
+                    count: total,
+                    note: `Immediate children of ${resolvedPath}: ${foldersArr.length} folder(s), ${assetsArr.length} asset(s)`,
+                    method: 'asset_registry_listing'
+                };
             }
         }
         catch (err) {
@@ -202,10 +214,13 @@ except Exception as e:
         }
         // Fallback: return empty with explanation
         return {
+            success: true,
+            path: this.normalizeDir(dir),
+            summary: { total: 0, folders: 0, assets: 0 },
+            foldersList: [],
             assets: [],
-            warning: 'Directory contains too many assets. Showing immediate children only.',
-            suggestion: 'Navigate to specific subdirectories for detailed listings.',
-            method: 'directory_timeout_fallback'
+            warning: 'No items at this path or failed to query AssetRegistry.',
+            method: 'asset_registry_fallback'
         };
     }
     async find(assetPath) {
@@ -213,9 +228,11 @@ except Exception as e:
         if (!assetPath || typeof assetPath !== 'string' || assetPath.trim() === '' || assetPath.endsWith('/')) {
             return false;
         }
+        // Normalize asset path (support users passing /Content/...)
+        const ap = this.normalizeDir(assetPath);
         const py = `
 import unreal
-apath = r"${assetPath}"
+apath = r"${ap}"
 try:
     exists = unreal.EditorAssetLibrary.does_asset_exist(apath)
     print("RESULT:{'success': True, 'exists': %s}" % ('True' if exists else 'False'))
@@ -223,21 +240,12 @@ except Exception as e:
     print("RESULT:{'success': False, 'error': '" + str(e) + "'}")
 `.trim();
         const resp = await this.bridge.executePython(py);
-        let output = '';
-        if (resp?.LogOutput && Array.isArray(resp.LogOutput))
-            output = resp.LogOutput.map((l) => l.Output || '').join('');
-        else if (typeof resp === 'string')
-            output = resp;
-        else
-            output = JSON.stringify(resp);
-        const m = output.match(/RESULT:({.*})/);
-        if (m) {
-            try {
-                const parsed = JSON.parse(m[1].replace(/'/g, '"'));
-                if (parsed.success)
-                    return !!parsed.exists;
-            }
-            catch { }
+        const interpreted = interpretStandardResult(resp, {
+            successMessage: 'Asset existence verified',
+            failureMessage: 'Failed to verify asset existence'
+        });
+        if (interpreted.success) {
+            return coerceBoolean(interpreted.payload.exists, false) ?? false;
         }
         return false;
     }

package/dist/resources/levels.d.ts

@@ -2,15 +2,33 @@ import { UnrealBridge } from '../unreal-bridge.js';
 export declare class LevelResources {
     private bridge;
     constructor(bridge: UnrealBridge);
-    getCurrentLevel(): Promise<any>;
-    getLevelName(): Promise<any>;
+    getCurrentLevel(): Promise<{
+        success: boolean;
+        name: string;
+        path: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        name?: undefined;
+        path?: undefined;
+    }>;
+    getLevelName(): Promise<{
+        success: boolean;
+        path: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        path?: undefined;
+    }>;
     saveCurrentLevel(): Promise<{
         success: boolean;
         message: string;
         error?: undefined;
     } | {
-        error: string;
         success: boolean;
+        error: string;
         message?: undefined;
     }>;
 }

package/dist/resources/levels.js

@@ -1,3 +1,4 @@
+import { coerceString, interpretStandardResult } from '../utils/result-helpers.js';
 export class LevelResources {
     bridge;
     constructor(bridge) {
@@ -8,25 +9,18 @@ export class LevelResources {
         try {
             const py = '\nimport unreal, json\ntry:\n    # Use UnrealEditorSubsystem instead of deprecated EditorLevelLibrary\n    editor_subsys = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)\n    world = editor_subsys.get_editor_world()\n    name = world.get_name() if world else \'None\'\n    path = world.get_path_name() if world else \'None\'\n    print(\'RESULT:\' + json.dumps({\'success\': True, \'name\': name, \'path\': path}))\nexcept Exception as e:\n    print(\'RESULT:\' + json.dumps({\'success\': False, \'error\': str(e)}))\n'.trim();
             const resp = await this.bridge.executePython(py);
-            // Handle LogOutput format from executePython
-            let out = '';
-            if (resp?.LogOutput && Array.isArray(resp.LogOutput)) {
-                out = resp.LogOutput.map((log) => log.Output || '').join('');
+            const interpreted = interpretStandardResult(resp, {
+                successMessage: 'Retrieved current level',
+                failureMessage: 'Failed to get current level'
+            });
+            if (interpreted.success) {
+                return {
+                    success: true,
+                    name: coerceString(interpreted.payload.name) ?? coerceString(interpreted.payload.level_name) ?? 'None',
+                    path: coerceString(interpreted.payload.path) ?? 'None'
+                };
             }
-            else if (typeof resp === 'string') {
-                out = resp;
-            }
-            else {
-                out = JSON.stringify(resp);
-            }
-            const m = out.match(/RESULT:({.*})/);
-            if (m) {
-                const parsed = JSON.parse(m[1]);
-                if (parsed.success)
-                    return parsed;
-            }
-            // If Python failed, return error
-            return { error: 'Failed to get current level', success: false };
+            return { success: false, error: interpreted.error ?? interpreted.message };
         }
         catch (err) {
             return { error: `Failed to get current level: ${err}`, success: false };
@@ -37,54 +31,35 @@ export class LevelResources {
         try {
             const py = '\nimport unreal, json\ntry:\n    # Use UnrealEditorSubsystem instead of deprecated EditorLevelLibrary\n    editor_subsys = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)\n    world = editor_subsys.get_editor_world()\n    path = world.get_path_name() if world else \'\'\n    print(\'RESULT:\' + json.dumps({\'success\': True, \'path\': path}))\nexcept Exception as e:\n    print(\'RESULT:\' + json.dumps({\'success\': False, \'error\': str(e)}))\n'.trim();
             const resp = await this.bridge.executePython(py);
-            // Handle LogOutput format from executePython
-            let out = '';
-            if (resp?.LogOutput && Array.isArray(resp.LogOutput)) {
-                out = resp.LogOutput.map((log) => log.Output || '').join('');
-            }
-            else if (typeof resp === 'string') {
-                out = resp;
-            }
-            else {
-                out = JSON.stringify(resp);
+            const interpreted = interpretStandardResult(resp, {
+                successMessage: 'Retrieved level path',
+                failureMessage: 'Failed to get level name'
+            });
+            if (interpreted.success) {
+                return {
+                    success: true,
+                    path: coerceString(interpreted.payload.path) ?? ''
+                };
             }
-            const m = out.match(/RESULT:({.*})/);
-            if (m) {
-                const parsed = JSON.parse(m[1]);
-                if (parsed.success)
-                    return parsed;
-            }
-            // If Python failed, return error
-            return { error: 'Failed to get level name', success: false };
+            return { success: false, error: interpreted.error ?? interpreted.message };
         }
         catch (err) {
             return { error: `Failed to get level name: ${err}`, success: false };
         }
     }
     async saveCurrentLevel() {
-        // Prefer Python save (or LevelEditorSubsystem) then fallback
+        // Strict modern API: require LevelEditorSubsystem
         try {
-            const py = '\nimport unreal, json\ntry:\n    les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)\n    if les: les.save_current_level()\n    else: unreal.EditorLevelLibrary.save_current_level()\n    print(\'RESULT:\' + json.dumps({\'success\': True}))\nexcept Exception as e:\n    print(\'RESULT:\' + json.dumps({\'success\': False, \'error\': str(e)}))\n'.trim();
+            const py = '\nimport unreal, json\ntry:\n    les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)\n    if not les:\n        print(\'RESULT:\' + json.dumps({\'success\': False, \'error\': \'LevelEditorSubsystem not available\'}))\n    else:\n        les.save_current_level()\n        print(\'RESULT:\' + json.dumps({\'success\': True}))\nexcept Exception as e:\n    print(\'RESULT:\' + json.dumps({\'success\': False, \'error\': str(e)}))\n'.trim();
             const resp = await this.bridge.executePython(py);
-            // Handle LogOutput format from executePython
-            let out = '';
-            if (resp?.LogOutput && Array.isArray(resp.LogOutput)) {
-                out = resp.LogOutput.map((log) => log.Output || '').join('');
-            }
-            else if (typeof resp === 'string') {
-                out = resp;
-            }
-            else {
-                out = JSON.stringify(resp);
-            }
-            const m = out.match(/RESULT:({.*})/);
-            if (m) {
-                const parsed = JSON.parse(m[1]);
-                if (parsed.success)
-                    return { success: true, message: 'Level saved' };
+            const interpreted = interpretStandardResult(resp, {
+                successMessage: 'Level saved',
+                failureMessage: 'Failed to save level'
+            });
+            if (interpreted.success) {
+                return { success: true, message: interpreted.message };
             }
-            // If Python failed, return error
-            return { error: 'Failed to save level', success: false };
+            return { success: false, error: interpreted.error ?? interpreted.message };
         }
         catch (err) {
             return { error: `Failed to save level: ${err}`, success: false };

package/dist/tools/actors.d.ts

@@ -14,20 +14,8 @@ export declare class ActorTools {
             yaw: number;
             roll: number;
         };
-    }): Promise<any>;
-    spawnViaPython(params: {
-        classPath: string;
-        location?: {
-            x: number;
-            y: number;
-            z: number;
-        };
-        rotation?: {
-            pitch: number;
-            yaw: number;
-            roll: number;
-        };
-    }): Promise<any>;
+        actorName?: string;
+    }): Promise<Record<string, unknown>>;
     spawnViaConsole(params: {
         classPath: string;
         location?: {
@@ -45,6 +33,7 @@ export declare class ActorTools {
         message: string;
         note: string;
     }>;
+    private getPythonSpawnHelper;
     private resolveActorClass;
     private getConsoleClassName;
 }