unreal-engine-mcp-server 0.4.7 → 0.5.0

package/src/prompts/index.ts

@@ -16,20 +16,20 @@ export interface PromptTemplate {
   }>;
 }
 
-function clampChoice(value: unknown, choices: string[], fallback: string): string {
+function clampChoice(value: unknown, choices: string[], defaultChoice: string): string {
   if (typeof value === 'string') {
     const normalized = value.toLowerCase();
     if (choices.includes(normalized)) {
       return normalized;
     }
   }
-  return fallback;
+  return defaultChoice;
 }
 
-function coerceNumber(value: unknown, fallback: number, min?: number, max?: number): number {
+function coerceNumber(value: unknown, defaultValue: number, min?: number, max?: number): number {
   const num = typeof value === 'number' ? value : Number(value);
   if (!Number.isFinite(num)) {
-    return fallback;
+    return defaultValue;
   }
   if (min !== undefined && num < min) {
     return min;

package/src/resources/actors.ts

@@ -1,5 +1,5 @@
 import { UnrealBridge } from '../unreal-bridge.js';
-import { bestEffortInterpretedText, coerceNumber, coerceString, interpretStandardResult } from '../utils/result-helpers.js';
+import { coerceNumber, coerceString } from '../utils/result-helpers.js';
 
 interface CacheEntry {
   data: any;
@@ -9,8 +9,11 @@ interface CacheEntry {
 export class ActorResources {
   private cache = new Map<string, CacheEntry>();
   private readonly CACHE_TTL_MS = 5000; // 5 seconds cache for actors (they change more frequently)
-  
-  constructor(private bridge: UnrealBridge) {}
+  private automationBridgeAvailable = false;
+
+  constructor(private bridge: UnrealBridge, private automationBridge?: any) {
+    this.automationBridgeAvailable = Boolean(automationBridge && typeof automationBridge.sendAutomationRequest === 'function');
+  }
   
   private getFromCache(key: string): any | null {
     const entry = this.cache.get(key);
@@ -32,114 +35,93 @@ export class ActorResources {
       return cached;
     }
     
-    // Use Python to get actors via EditorActorSubsystem
     try {
-  const pythonCode = `
-import unreal, json
-actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-actors = actor_subsystem.get_all_level_actors() if actor_subsystem else []
-actor_list = []
-for actor in actors:
-    try:
-        if actor:
-            actor_list.append({
-                'name': actor.get_name(),
-                'class': actor.get_class().get_name(),
-                'path': actor.get_path_name()
-            })
-    except Exception:
-        pass
-print('RESULT:' + json.dumps({'success': True, 'count': len(actor_list), 'actors': actor_list}))
-      `.trim();
-      
-      const response = await this.bridge.executePython(pythonCode);
-      const interpreted = interpretStandardResult(response, {
-        successMessage: 'Retrieved actor list',
-        failureMessage: 'Failed to retrieve actor list'
-      });
+      if (!this.automationBridgeAvailable) {
+        return { success: false, error: 'Automation bridge is not available. Please ensure Unreal Engine is running with the MCP Automation Bridge plugin.' };
+      }
 
-      if (interpreted.success && Array.isArray(interpreted.payload.actors)) {
-        const actors = interpreted.payload.actors as any[];
-        const count = coerceNumber(interpreted.payload.count) ?? actors.length;
-        const payload = {
-          success: true as const,
-          count,
-          actors
-        };
+      const resp: any = await this.automationBridge.sendAutomationRequest('control_actor', { action: 'list' });
+      if (resp && resp.success !== false && Array.isArray((resp.result || resp).actors)) {
+        const actors = (resp.result || resp).actors as any[];
+        const count = coerceNumber((resp.result || resp).count) ?? actors.length;
+        const payload = { success: true as const, count, actors };
         this.setCache('listActors', payload);
         return payload;
       }
 
-      return {
-        success: false,
-        error: coerceString(interpreted.payload.error) ?? interpreted.error ?? 'Failed to parse actors list',
-        note: bestEffortInterpretedText(interpreted)
-      };
+      return { success: false, error: 'Failed to retrieve actor list from automation bridge' };
     } catch (err) {
       return { success: false, error: `Failed to list actors: ${err}` };
     }
   }
 
   async getActorByName(actorName: string) {
-    // GetActorOfClass expects a class, not a name. Use Python to find by name
     try {
-      const pythonCode = `
-import unreal
-import json
-
-actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-actors = actor_subsystem.get_all_level_actors() if actor_subsystem else []
-
-found = None
-for actor in actors:
-    if actor and actor.get_name() == ${JSON.stringify(actorName)}:
-        found = {
-            'success': True,
-            'name': actor.get_name(),
-            'path': actor.get_path_name(),
-            'class': actor.get_class().get_name()
-        }
-        break
-
-if not found:
-    found = {'success': False, 'error': f"Actor not found: {actorName}"}
-
-print('RESULT:' + json.dumps(found))
-      `.trim();
+      if (!this.automationBridgeAvailable) {
+        return { success: false, error: 'Automation bridge is not available' };
+      }
 
-      const response = await this.bridge.executePython(pythonCode);
-      const interpreted = interpretStandardResult(response, {
-        successMessage: `Actor resolved: ${actorName}`,
-        failureMessage: `Actor not found: ${actorName}`
+      const resp: any = await this.automationBridge.sendAutomationRequest('control_actor', {
+        action: 'find_by_name',
+        name: actorName
       });
 
-      if (interpreted.success) {
+      if (resp && resp.success !== false && resp.result) {
         return {
           success: true as const,
-          name: coerceString(interpreted.payload.name) ?? actorName,
-          path: coerceString(interpreted.payload.path),
-          class: coerceString(interpreted.payload.class)
+          name: coerceString(resp.result.name) ?? actorName,
+          path: coerceString(resp.result.path),
+          class: coerceString(resp.result.class)
         };
       }
 
       return {
         success: false as const,
-        error: coerceString(interpreted.payload.error) ?? interpreted.error ?? `Actor not found: ${actorName}`
+        error: `Actor not found: ${actorName}`
       };
     } catch (err) {
-      return { error: `Failed to get actor: ${err}` };
+      return { success: false, error: `Failed to get actor: ${err}` };
     }
   }
 
   async getActorTransform(actorPath: string) {
     try {
-      const res = await this.bridge.httpCall('/remote/object/property', 'GET', {
+      return await this.bridge.getObjectProperty({
         objectPath: actorPath,
         propertyName: 'ActorTransform'
       });
-      return res;
     } catch (err) {
       return { error: `Failed to get transform: ${err}` };
     }
   }
+
+  async listActorComponents(actorPath: string) {
+    try {
+      if (!this.automationBridgeAvailable) {
+        return { success: false, error: 'Automation bridge is not available' };
+      }
+
+      const resp: any = await this.automationBridge.sendAutomationRequest('control_actor', {
+        action: 'list_components',
+        actor_path: actorPath
+      });
+
+      if (resp && resp.success !== false && Array.isArray(resp.result?.components)) {
+        return {
+          success: true as const,
+          components: resp.result.components
+        };
+      }
+
+      return {
+        success: false as const,
+        error: `Failed to resolve components for ${actorPath}`
+      };
+    } catch (err) {
+      return {
+        success: false as const,
+        error: `Component lookup failed: ${err}`
+      };
+    }
+  }
 }

package/src/resources/assets.ts

@@ -1,14 +1,13 @@
-import { UnrealBridge } from '../unreal-bridge.js';
-import { coerceBoolean, coerceString, interpretStandardResult } from '../utils/result-helpers.js';
-
-export class AssetResources {
-  constructor(private bridge: UnrealBridge) {}
+import { BaseTool } from '../tools/base-tool.js';
+import { IAssetResources } from '../types/tool-interfaces.js';
+import { coerceString } from '../utils/result-helpers.js';
 
+export class AssetResources extends BaseTool implements IAssetResources {
   // Simple in-memory cache for asset listing
   private cache = new Map<string, { timestamp: number; data: any }>();
   private get ttlMs(): number { return Number(process.env.ASSET_LIST_TTL_MS || 10000); }
-  private makeKey(dir: string, recursive: boolean, page?: number) { 
-    return page !== undefined ? `${dir}::${recursive ? 1 : 0}::${page}` : `${dir}::${recursive ? 1 : 0}`; 
+  private makeKey(dir: string, recursive: boolean, page?: number) {
+    return page !== undefined ? `${dir}::${recursive ? 1 : 0}::${page}` : `${dir}::${recursive ? 1 : 0}`;
   }
 
   // Normalize UE content paths:
@@ -32,11 +31,48 @@ export class AssetResources {
     }
   }
 
+  clearCache(dir?: string) {
+    if (!dir) {
+      this.cache.clear();
+      return;
+    }
+
+    const normalized = this.normalizeDir(dir);
+    for (const key of Array.from(this.cache.keys())) {
+      if (key.startsWith(`${normalized}::`)) {
+        this.cache.delete(key);
+      }
+    }
+  }
+
+  invalidateAssetPaths(paths: string[]) {
+    if (!Array.isArray(paths) || paths.length === 0) {
+      return;
+    }
+
+    const dirs = new Set<string>();
+    for (const rawPath of paths) {
+      if (typeof rawPath !== 'string' || rawPath.trim().length === 0) {
+        continue;
+      }
+      const normalized = this.normalizeDir(rawPath);
+      dirs.add(normalized);
+      const parent = this.parentDirectory(normalized);
+      if (parent) {
+        dirs.add(parent);
+      }
+    }
+
+    for (const dir of dirs) {
+      this.clearCache(dir);
+    }
+  }
+
   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);
 
@@ -46,22 +82,24 @@ export class AssetResources {
       const entry = this.cache.get(key);
       const now = Date.now();
       if (entry && (now - entry.timestamp) < this.ttlMs) {
-        return entry.data;
+        return { success: true, ...entry.data };
       }
-    } catch {}
-    
+    } catch { }
+
     // Check if bridge is connected
     if (!this.bridge.isConnected) {
       return {
+        success: false,
         assets: [],
-        warning: 'Unreal Engine is not connected. Please ensure Unreal Engine is running with Remote Control enabled.',
+        warning: 'Unreal Engine is not connected. Please ensure Unreal Engine is running with the MCP server enabled.',
         connectionStatus: 'disconnected'
       };
     }
-    
+
     // Always use directory-only listing (immediate children)
-    return this.listDirectoryOnly(dir, false, limit);
-    // End of list method - all logic is now in listDirectoryOnly
+    const listed = await this.listDirectoryOnly(dir, false, limit);
+    // Ensure a success flag is present so downstream evaluators don't assume success implicitly
+    return { ...listed, success: listed && (listed as any).success === false ? false : true };
   }
 
   /**
@@ -74,7 +112,7 @@ export class AssetResources {
     // Ensure pageSize doesn't exceed safe limit
     const safePageSize = Math.min(pageSize, 50);
     const offset = page * safePageSize;
-    
+
     // Normalize directory and check cache for this specific page
     dir = this.normalizeDir(dir);
     const cacheKey = this.makeKey(dir, recursive, page);
@@ -82,7 +120,7 @@ export class AssetResources {
     if (cached && (Date.now() - cached.timestamp) < this.ttlMs) {
       return cached.data;
     }
-    
+
     if (!this.bridge.isConnected) {
       return {
         assets: [],
@@ -92,17 +130,17 @@ export class AssetResources {
         connectionStatus: 'disconnected'
       };
     }
-    
+
     try {
       // Use search API with pagination
       // Use the same directory listing approach but with pagination
       const allAssets = await this.listDirectoryOnly(dir, false, 1000);
-      
+
       // Paginate the results
       const start = offset;
       const end = offset + safePageSize;
       const pagedAssets = allAssets.assets ? allAssets.assets.slice(start, end) : [];
-      
+
       const result = {
         assets: pagedAssets,
         page,
@@ -112,13 +150,13 @@ export class AssetResources {
         hasMore: end < (allAssets.assets ? allAssets.assets.length : 0),
         method: 'directory_listing_paged'
       };
-      
+
       this.cache.set(cacheKey, { timestamp: Date.now(), data: result });
       return result;
     } catch (err: any) {
       console.warn(`Asset listing page ${page} failed:`, err.message);
     }
-    
+
     return {
       assets: [],
       page,
@@ -134,109 +172,80 @@ export class AssetResources {
   private async listDirectoryOnly(dir: string, _recursive: boolean, limit: number) {
     // Always return only immediate children to avoid timeout and improve navigation
     try {
-      const py = `
-import unreal
-import json
-
-_dir = r"${this.normalizeDir(dir)}"
-
-try:
-    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,
-        '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), 'path': _dir}))
-`.trim();
-
-      const resp = await this.bridge.executePython(py);
-      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) ?? '',
+      // Use the native C++ plugin's list action instead of Python
+      try {
+        const normalizedDir = this.normalizeDir(dir);
+        const response = await this.sendAutomationRequest(
+          'list',
+          { directory: normalizedDir, limit, recursive: false },
+          { timeoutMs: 30000 }
+        );
+
+        if (response.success !== false && response.result) {
+          const payload = response.result;
+
+          const foldersArr = Array.isArray(payload.folders_list)
+            ? payload.folders_list.map((f: any) => ({
+              Name: coerceString(f?.n ?? f?.Name ?? f?.name) ?? '',
+              Path: coerceString(f?.p ?? f?.Path ?? f?.path) ?? '',
               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 assetsArr = Array.isArray(payload.assets)
+            ? payload.assets.map((a: any) => ({
+              Name: coerceString(a?.n ?? a?.Name ?? a?.name) ?? '',
+              Path: coerceString(a?.p ?? a?.Path ?? a?.path) ?? '',
+              Class: coerceString(a?.c ?? a?.Class ?? a?.class) ?? 'Object'
             }))
-          : [];
-
-        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'
-        };
-      }
+            : [];
+
+          const result = {
+            success: true,
+            assets: [...foldersArr, ...assetsArr],
+            count: foldersArr.length + assetsArr.length,
+            folders: foldersArr.length,
+            files: assetsArr.length,
+            path: normalizedDir,
+            recursive: false,
+            method: 'automation_bridge',
+            cached: false
+          };
+
+          const key = this.makeKey(dir, false);
+          this.cache.set(key, { timestamp: Date.now(), data: result });
+          return result;
+        }
+      } catch { }
+
+      // No fallback available
     } catch (err: any) {
-      console.warn('Engine asset listing failed:', err.message);
+      const errorMessage = err?.message ? String(err.message) : 'Asset registry request failed';
+      console.warn('Engine asset listing failed:', errorMessage);
+      return {
+        success: false,
+        path: this.normalizeDir(dir),
+        summary: { total: 0, folders: 0, assets: 0 },
+        foldersList: [],
+        assets: [],
+        error: errorMessage,
+        warning: 'AssetRegistry query failed. Ensure the MCP Automation Bridge is connected.',
+        transport: 'automation_bridge',
+        method: 'asset_registry_alternate'
+      };
     }
-    
-    // Fallback: return empty with explanation
+
     return {
-      success: true,
+      success: false,
       path: this.normalizeDir(dir),
       summary: { total: 0, folders: 0, assets: 0 },
       foldersList: [],
       assets: [],
-      warning: 'No items at this path or failed to query AssetRegistry.',
-      method: 'asset_registry_fallback'
+      error: 'Asset registry returned no payload.',
+      warning: 'No items returned from AssetRegistry request.',
+      transport: 'automation_bridge',
+      method: 'asset_registry_empty'
     };
   }
 
@@ -246,27 +255,31 @@ except Exception as e:
       return false;
     }
 
-    // Normalize asset path (support users passing /Content/...)
-    const ap = this.normalizeDir(assetPath);
-    const py = `
-import unreal
-apath = r"${ap}"
-try:
-    exists = unreal.EditorAssetLibrary.does_asset_exist(apath)
-    print("RESULT:{'success': True, 'exists': %s}" % ('True' if exists else 'False'))
-except Exception as e:
-    print("RESULT:{'success': False, 'error': '" + str(e) + "'}")
-`.trim();
-    const resp = await this.bridge.executePython(py);
-    const interpreted = interpretStandardResult(resp, {
-      successMessage: 'Asset existence verified',
-      failureMessage: 'Failed to verify asset existence'
-    });
-
-    if (interpreted.success) {
-      return coerceBoolean(interpreted.payload.exists, false) ?? false;
+    try {
+      const normalizedPath = this.normalizeDir(assetPath);
+      const response = await this.sendAutomationRequest(
+        'asset_exists',
+        { asset_path: normalizedPath }
+      );
+
+      return response?.success !== false && response?.result?.exists === true;
+    } catch {
+      return false;
+    }
+  }
+
+  private parentDirectory(path: string): string | null {
+    if (!path || typeof path !== 'string') {
+      return null;
+    }
+
+    const normalized = this.normalizeDir(path);
+    const lastSlash = normalized.lastIndexOf('/');
+    if (lastSlash <= 0) {
+      return normalized === '/' ? '/' : null;
     }
 
-    return false;
+    const parent = normalized.substring(0, lastSlash);
+    return parent.length > 0 ? parent : '/';
   }
 }