unreal-engine-mcp-server 0.2.1

package/dist/resources/actors.js

@@ -0,0 +1,83 @@
+export class ActorResources {
+    bridge;
+    cache = new Map();
+    CACHE_TTL_MS = 5000; // 5 seconds cache for actors (they change more frequently)
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    getFromCache(key) {
+        const entry = this.cache.get(key);
+        if (entry && (Date.now() - entry.timestamp) < this.CACHE_TTL_MS) {
+            return entry.data;
+        }
+        this.cache.delete(key);
+        return null;
+    }
+    setCache(key, data) {
+        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
+actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
+actors = actor_subsystem.get_all_level_actors()
+actor_list = []
+for actor in actors:
+    if actor:
+        actor_list.append({
+            'name': actor.get_name(),
+            'class': actor.get_class().get_name(),
+            'path': actor.get_path_name()
+        })
+print(f"Found {len(actor_list)} actors")
+      `.trim();
+            const result = await this.bridge.executePython(pythonCode);
+            this.setCache('listActors', result);
+            return result;
+        }
+        catch (err) {
+            return { 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
+actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
+actors = actor_subsystem.get_all_level_actors()
+for actor in actors:
+    if actor and actor.get_name() == "${actorName}":
+        print(f"Found actor: {actor.get_path_name()}")
+        break
+else:
+    print(f"Actor not found: ${actorName}")
+      `.trim();
+            const result = await this.bridge.executePython(pythonCode);
+            return result;
+        }
+        catch (err) {
+            return { error: `Failed to get actor: ${err}` };
+        }
+    }
+    async getActorTransform(actorPath) {
+        try {
+            const res = await this.bridge.httpCall('/remote/object/property', 'GET', {
+                objectPath: actorPath,
+                propertyName: 'ActorTransform'
+            });
+            return res;
+        }
+        catch (err) {
+            return { error: `Failed to get transform: ${err}` };
+        }
+    }
+}
+//# sourceMappingURL=actors.js.map

package/dist/resources/assets.d.ts

@@ -0,0 +1,23 @@
+import { UnrealBridge } from '../unreal-bridge.js';
+export declare class AssetResources {
+    private bridge;
+    constructor(bridge: UnrealBridge);
+    private cache;
+    private get ttlMs();
+    private makeKey;
+    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 for paths with too many assets
+     * Shows only immediate children (folders and files) to avoid timeouts
+     */
+    private listDirectoryOnly;
+    find(assetPath: string): Promise<boolean>;
+}
+//# sourceMappingURL=assets.d.ts.map

package/dist/resources/assets.js

@@ -0,0 +1,245 @@
+export class AssetResources {
+    bridge;
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    // Simple in-memory cache for asset listing
+    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}`;
+    }
+    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
+        // 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;
+            }
+        }
+        catch { }
+        // Check if bridge is connected
+        if (!this.bridge.isConnected) {
+            return {
+                assets: [],
+                warning: 'Unreal Engine is not connected. Please ensure Unreal Engine is running with Remote Control 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
+    }
+    /**
+     * 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;
+        // Check cache for this specific page
+        const cacheKey = this.makeKey(dir, recursive, page);
+        const cached = this.cache.get(cacheKey);
+        if (cached && (Date.now() - cached.timestamp) < this.ttlMs) {
+            return cached.data;
+        }
+        if (!this.bridge.isConnected) {
+            return {
+                assets: [],
+                page,
+                pageSize: safePageSize,
+                warning: 'Unreal Engine is not connected.',
+                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,
+                pageSize: safePageSize,
+                count: pagedAssets.length,
+                totalCount: allAssets.assets ? allAssets.assets.length : 0,
+                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) {
+            console.warn(`Asset listing page ${page} failed:`, err.message);
+        }
+        return {
+            assets: [],
+            page,
+            pageSize: safePageSize,
+            error: 'Failed to fetch page'
+        };
+    }
+    /**
+     * Directory-based listing for paths with too many assets
+     * Shows only immediate children (folders and files) to avoid timeouts
+     */
+    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"${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)'
+    
+    print("RESULT:" + json.dumps({
+        'success': True, 
+        'assets': result, 
+        'count': len(result),
+        'folders': len(immediate_folders),
+        'files': len(immediate_assets),
+        'note': note
+    }))
+except Exception as e:
+    print("RESULT:" + json.dumps({'success': False, 'error': str(e), 'assets': []}))
+`.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 { }
+            }
+        }
+        catch (err) {
+            console.warn('Engine asset listing failed:', err.message);
+        }
+        // Fallback: return empty with explanation
+        return {
+            assets: [],
+            warning: 'Directory contains too many assets. Showing immediate children only.',
+            suggestion: 'Navigate to specific subdirectories for detailed listings.',
+            method: 'directory_timeout_fallback'
+        };
+    }
+    async find(assetPath) {
+        // Guard against invalid paths (trailing slash, empty, whitespace)
+        if (!assetPath || typeof assetPath !== 'string' || assetPath.trim() === '' || assetPath.endsWith('/')) {
+            return false;
+        }
+        const py = `
+import unreal
+apath = r"${assetPath}"
+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);
+        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 { }
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=assets.js.map

package/dist/resources/levels.d.ts

@@ -0,0 +1,17 @@
+import { UnrealBridge } from '../unreal-bridge.js';
+export declare class LevelResources {
+    private bridge;
+    constructor(bridge: UnrealBridge);
+    getCurrentLevel(): Promise<any>;
+    getLevelName(): Promise<any>;
+    saveCurrentLevel(): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        error: string;
+        success: boolean;
+        message?: undefined;
+    }>;
+}
+//# sourceMappingURL=levels.d.ts.map

package/dist/resources/levels.js

@@ -0,0 +1,94 @@
+export class LevelResources {
+    bridge;
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    async getCurrentLevel() {
+        // Use UnrealEditorSubsystem instead of deprecated EditorLevelLibrary
+        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('');
+            }
+            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 };
+        }
+        catch (err) {
+            return { error: `Failed to get current level: ${err}`, success: false };
+        }
+    }
+    async getLevelName() {
+        // Return camera/world info via Python first
+        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 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 };
+        }
+        catch (err) {
+            return { error: `Failed to get level name: ${err}`, success: false };
+        }
+    }
+    async saveCurrentLevel() {
+        // Prefer Python save (or LevelEditorSubsystem) then fallback
+        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 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' };
+            }
+            // If Python failed, return error
+            return { error: 'Failed to save level', success: false };
+        }
+        catch (err) {
+            return { error: `Failed to save level: ${err}`, success: false };
+        }
+    }
+}
+//# sourceMappingURL=levels.js.map

package/dist/tools/actors.d.ts

@@ -0,0 +1,51 @@
+import { UnrealBridge } from '../unreal-bridge.js';
+export declare class ActorTools {
+    private bridge;
+    constructor(bridge: UnrealBridge);
+    spawn(params: {
+        classPath: string;
+        location?: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        rotation?: {
+            pitch: number;
+            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>;
+    spawnViaConsole(params: {
+        classPath: string;
+        location?: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        rotation?: {
+            pitch: number;
+            yaw: number;
+            roll: number;
+        };
+    }): Promise<{
+        success: boolean;
+        message: string;
+        note: string;
+    }>;
+    private resolveActorClass;
+    private getConsoleClassName;
+}
+//# sourceMappingURL=actors.d.ts.map