unreal-engine-mcp-server 0.3.1 → 0.4.3

package/src/resources/assets.ts

@@ -1,4 +1,5 @@
 import { UnrealBridge } from '../unreal-bridge.js';
+import { coerceBoolean, coerceString, interpretStandardResult } from '../utils/result-helpers.js';
 
 export class AssetResources {
   constructor(private bridge: UnrealBridge) {}
@@ -10,11 +11,35 @@ export class AssetResources {
     return page !== undefined ? `${dir}::${recursive ? 1 : 0}::${page}` : `${dir}::${recursive ? 1 : 0}`; 
   }
 
+  // Normalize UE content paths:
+  // - Map '/Content' -> '/Game'
+  // - Ensure forward slashes
+  private normalizeDir(dir: string): string {
+    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);
@@ -50,7 +75,8 @@ export class AssetResources {
     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) {
@@ -102,8 +128,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.
    */
   private async listDirectoryOnly(dir: string, _recursive: boolean, limit: number) {
     // Always return only immediate children to avoid timeout and improve navigation
@@ -112,100 +138,91 @@ 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: any) => 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: any) => ({
-              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 as Record<string, unknown>;
+
+        const foldersArr = Array.isArray(payload.folders_list)
+          ? payload.folders_list.map((f: any) => ({
+              Name: coerceString(f?.n) ?? '',
+              Path: coerceString(f?.p) ?? '',
+              Class: 'Folder',
+              isFolder: true
+            }))
+          : [];
+
+        const assetsArr = Array.isArray(payload.assets)
+          ? payload.assets.map((a: any) => ({
+              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: any) {
       console.warn('Engine asset listing failed:', err.message);
@@ -213,10 +230,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'
     };
   }
 
@@ -226,9 +246,11 @@ except Exception as e:
       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'))
@@ -236,16 +258,15 @@ 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: any) => 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/src/resources/levels.ts

@@ -1,4 +1,5 @@
 import { UnrealBridge } from '../unreal-bridge.js';
+import { coerceString, interpretStandardResult } from '../utils/result-helpers.js';
 
 export class LevelResources {
   constructor(private bridge: UnrealBridge) {}
@@ -8,22 +9,20 @@ 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: any = await this.bridge.executePython(py);
-      // Handle LogOutput format from executePython
-      let out = '';
-      if (resp?.LogOutput && Array.isArray(resp.LogOutput)) {
-        out = resp.LogOutput.map((log: any) => 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 parsed;
+      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'
+        };
       }
-      // 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 };
     }
@@ -34,48 +33,39 @@ 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: any = await this.bridge.executePython(py);
-      // Handle LogOutput format from executePython
-      let out = '';
-      if (resp?.LogOutput && Array.isArray(resp.LogOutput)) {
-        out = resp.LogOutput.map((log: any) => 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 parsed;
+      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) ?? ''
+        };
       }
-      // 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: any = await this.bridge.executePython(py);
-      // Handle LogOutput format from executePython
-      let out = '';
-      if (resp?.LogOutput && Array.isArray(resp.LogOutput)) {
-        out = resp.LogOutput.map((log: any) => 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 };
     }