unreal-engine-mcp-server 0.4.7 → 0.5.0

package/dist/prompts/index.js

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

package/dist/resources/actors.d.ts

@@ -1,31 +1,36 @@
 import { UnrealBridge } from '../unreal-bridge.js';
 export declare class ActorResources {
     private bridge;
+    private automationBridge?;
     private cache;
     private readonly CACHE_TTL_MS;
-    constructor(bridge: UnrealBridge);
+    private automationBridgeAvailable;
+    constructor(bridge: UnrealBridge, automationBridge?: any | undefined);
     private getFromCache;
     private setCache;
     listActors(): Promise<any>;
     getActorByName(actorName: string): Promise<{
+        success: boolean;
+        error: string;
+        name?: undefined;
+        path?: undefined;
+        class?: undefined;
+    } | {
         success: true;
         name: string;
         path: string | undefined;
         class: string | undefined;
         error?: undefined;
-    } | {
-        success: false;
+    }>;
+    getActorTransform(actorPath: string): Promise<Record<string, any>>;
+    listActorComponents(actorPath: string): Promise<{
+        success: boolean;
         error: string;
-        name?: undefined;
-        path?: undefined;
-        class?: undefined;
+        components?: undefined;
     } | {
-        error: string;
-        success?: undefined;
-        name?: undefined;
-        path?: undefined;
-        class?: undefined;
+        success: true;
+        components: any;
+        error?: undefined;
     }>;
-    getActorTransform(actorPath: string): Promise<any>;
 }
 //# sourceMappingURL=actors.d.ts.map

package/dist/resources/actors.js

@@ -1,10 +1,14 @@
-import { bestEffortInterpretedText, coerceNumber, coerceString, interpretStandardResult } from '../utils/result-helpers.js';
+import { coerceNumber, coerceString } from '../utils/result-helpers.js';
 export class ActorResources {
     bridge;
+    automationBridge;
     cache = new Map();
-    CACHE_TTL_MS = 5000; // 5 seconds cache for actors (they change more frequently)
-    constructor(bridge) {
+    CACHE_TTL_MS = 5000;
+    automationBridgeAvailable = false;
+    constructor(bridge, automationBridge) {
         this.bridge = bridge;
+        this.automationBridge = automationBridge;
+        this.automationBridgeAvailable = Boolean(automationBridge && typeof automationBridge.sendAutomationRequest === 'function');
     }
     getFromCache(key) {
         const entry = this.cache.get(key);
@@ -18,115 +22,91 @@ export class ActorResources {
         this.cache.set(key, { data, timestamp: Date.now() });
     }
     async listActors() {
-        // Check cache first
         const cached = this.getFromCache('listActors');
         if (cached !== null) {
             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 (interpreted.success && Array.isArray(interpreted.payload.actors)) {
-                const actors = interpreted.payload.actors;
-                const count = coerceNumber(interpreted.payload.count) ?? actors.length;
-                const payload = {
-                    success: true,
-                    count,
-                    actors
-                };
+            if (!this.automationBridgeAvailable) {
+                return { success: false, error: 'Automation bridge is not available. Please ensure Unreal Engine is running with the MCP Automation Bridge plugin.' };
+            }
+            const resp = 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;
+                const count = coerceNumber((resp.result || resp).count) ?? actors.length;
+                const payload = { success: true, 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) {
-        // 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();
-            const response = await this.bridge.executePython(pythonCode);
-            const interpreted = interpretStandardResult(response, {
-                successMessage: `Actor resolved: ${actorName}`,
-                failureMessage: `Actor not found: ${actorName}`
+            if (!this.automationBridgeAvailable) {
+                return { success: false, error: 'Automation bridge is not available' };
+            }
+            const resp = 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,
-                    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,
-                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) {
         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) {
+        try {
+            if (!this.automationBridgeAvailable) {
+                return { success: false, error: 'Automation bridge is not available' };
+            }
+            const resp = 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,
+                    components: resp.result.components
+                };
+            }
+            return {
+                success: false,
+                error: `Failed to resolve components for ${actorPath}`
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: `Component lookup failed: ${err}`
+            };
+        }
+    }
 }
 //# sourceMappingURL=actors.js.map

package/dist/resources/assets.d.ts

@@ -1,24 +1,16 @@
-import { UnrealBridge } from '../unreal-bridge.js';
-export declare class AssetResources {
-    private bridge;
-    constructor(bridge: UnrealBridge);
+import { BaseTool } from '../tools/base-tool.js';
+import { IAssetResources } from '../types/tool-interfaces.js';
+export declare class AssetResources extends BaseTool implements IAssetResources {
     private cache;
     private get ttlMs();
     private makeKey;
     private normalizeDir;
+    clearCache(dir?: string): void;
+    invalidateAssetPaths(paths: string[]): void;
     list(dir?: string, _recursive?: boolean, limit?: number): Promise<any>;
-    /**
-     * List assets with pagination support
-     * @param dir Directory to list assets from
-     * @param page Page number (0-based)
-     * @param pageSize Number of assets per page (max 50 to avoid socket failures)
-     */
     listPaged(dir?: string, page?: number, pageSize?: number, recursive?: boolean): Promise<any>;
-    /**
-     * Directory-based listing of immediate children using AssetRegistry.
-     * Returns both subfolders and assets at the given path.
-     */
     private listDirectoryOnly;
     find(assetPath: string): Promise<boolean>;
+    private parentDirectory;
 }
 //# sourceMappingURL=assets.d.ts.map

package/dist/resources/assets.js

@@ -1,18 +1,11 @@
-import { coerceBoolean, coerceString, interpretStandardResult } from '../utils/result-helpers.js';
-export class AssetResources {
-    bridge;
-    constructor(bridge) {
-        this.bridge = bridge;
-    }
-    // Simple in-memory cache for asset listing
+import { BaseTool } from '../tools/base-tool.js';
+import { coerceString } from '../utils/result-helpers.js';
+export class AssetResources extends BaseTool {
     cache = new Map();
     get ttlMs() { return Number(process.env.ASSET_LIST_TTL_MS || 10000); }
     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')
@@ -23,9 +16,7 @@ export class AssetResources {
             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;
@@ -34,45 +25,64 @@ export class AssetResources {
             return '/Game';
         }
     }
+    clearCache(dir) {
+        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) {
+        if (!Array.isArray(paths) || paths.length === 0) {
+            return;
+        }
+        const dirs = new Set();
+        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
+        _recursive = false;
         dir = this.normalizeDir(dir);
-        // Cache fast-path
         try {
             const key = this.makeKey(dir, false);
             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 { }
-        // 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);
+        return { ...listed, success: listed && listed.success === false ? false : true };
     }
-    /**
-     * List assets with pagination support
-     * @param dir Directory to list assets from
-     * @param page Page number (0-based)
-     * @param pageSize Number of assets per page (max 50 to avoid socket failures)
-     */
     async listPaged(dir = '/Game', page = 0, pageSize = 30, recursive = false) {
-        // 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);
         const cached = this.cache.get(cacheKey);
@@ -89,10 +99,7 @@ export class AssetResources {
             };
         }
         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) : [];
@@ -118,136 +125,97 @@ export class AssetResources {
             error: 'Failed to fetch page'
         };
     }
-    /**
-     * 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
         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;
-                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'
-                };
+            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) => ({
+                            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) => ({
+                            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 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 { }
         }
         catch (err) {
-            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'
         };
     }
     async find(assetPath) {
-        // Guard against invalid paths (trailing slash, empty, whitespace)
         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"${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;
-        }
-        return 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;
+        }
+    }
+    parentDirectory(path) {
+        if (!path || typeof path !== 'string') {
+            return null;
+        }
+        const normalized = this.normalizeDir(path);
+        const lastSlash = normalized.lastIndexOf('/');
+        if (lastSlash <= 0) {
+            return normalized === '/' ? '/' : null;
+        }
+        const parent = normalized.substring(0, lastSlash);
+        return parent.length > 0 ? parent : '/';
     }
 }
 //# sourceMappingURL=assets.js.map