unreal-engine-mcp-server 0.4.0 → 0.4.4

package/dist/resources/actors.js

@@ -1,3 +1,4 @@
+import { bestEffortInterpretedText, coerceNumber, coerceString, interpretStandardResult } from '../utils/result-helpers.js';
 export class ActorResources {
     bridge;
     cache = new Map();
@@ -41,64 +42,27 @@ for actor in actors:
         pass
 print('RESULT:' + json.dumps({'success': True, 'count': len(actor_list), 'actors': actor_list}))
       `.trim();
-            const resp = await this.bridge.executePythonWithResult(pythonCode);
-            if (resp && typeof resp === 'object' && resp.success === true && Array.isArray(resp.actors)) {
-                this.setCache('listActors', resp);
-                return resp;
-            }
-            // Fallback manual extraction with bracket matching
-            const raw = await this.bridge.executePython(pythonCode);
-            let output = '';
-            if (raw?.LogOutput && Array.isArray(raw.LogOutput))
-                output = raw.LogOutput.map((l) => l.Output || '').join('');
-            else if (typeof raw === 'string')
-                output = raw;
-            else
-                output = JSON.stringify(raw);
-            const marker = 'RESULT:';
-            const idx = output.lastIndexOf(marker);
-            if (idx !== -1) {
-                let i = idx + marker.length;
-                while (i < output.length && output[i] !== '{')
-                    i++;
-                if (i < output.length) {
-                    let depth = 0, inStr = false, esc = false, j = i;
-                    for (; j < output.length; j++) {
-                        const ch = output[j];
-                        if (esc) {
-                            esc = false;
-                            continue;
-                        }
-                        if (ch === '\\') {
-                            esc = true;
-                            continue;
-                        }
-                        if (ch === '"') {
-                            inStr = !inStr;
-                            continue;
-                        }
-                        if (!inStr) {
-                            if (ch === '{')
-                                depth++;
-                            else if (ch === '}') {
-                                depth--;
-                                if (depth === 0) {
-                                    j++;
-                                    break;
-                                }
-                            }
-                        }
-                    }
-                    const jsonStr = output.slice(i, j);
-                    try {
-                        const parsed = JSON.parse(jsonStr);
-                        this.setCache('listActors', parsed);
-                        return parsed;
-                    }
-                    catch { }
-                }
+            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
+                };
+                this.setCache('listActors', payload);
+                return payload;
             }
-            return { success: false, error: 'Failed to parse actors list' };
+            return {
+                success: false,
+                error: coerceString(interpreted.payload.error) ?? interpreted.error ?? 'Failed to parse actors list',
+                note: bestEffortInterpretedText(interpreted)
+            };
         }
         catch (err) {
             return { success: false, error: `Failed to list actors: ${err}` };
@@ -109,17 +73,44 @@ print('RESULT:' + json.dumps({'success': True, 'count': len(actor_list), 'actors
         try {
             const pythonCode = `
 import unreal
+import json
+
 actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-actors = actor_subsystem.get_all_level_actors()
+actors = actor_subsystem.get_all_level_actors() if actor_subsystem else []
+
+found = None
 for actor in actors:
-    if actor and actor.get_name() == "${actorName}":
-        print(f"Found actor: {actor.get_path_name()}")
+    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
-else:
-    print(f"Actor not found: ${actorName}")
+
+if not found:
+    found = {'success': False, 'error': f"Actor not found: {actorName}"}
+
+print('RESULT:' + json.dumps(found))
       `.trim();
-            const result = await this.bridge.executePython(pythonCode);
-            return result;
+            const response = await this.bridge.executePython(pythonCode);
+            const interpreted = interpretStandardResult(response, {
+                successMessage: `Actor resolved: ${actorName}`,
+                failureMessage: `Actor not found: ${actorName}`
+            });
+            if (interpreted.success) {
+                return {
+                    success: true,
+                    name: coerceString(interpreted.payload.name) ?? actorName,
+                    path: coerceString(interpreted.payload.path),
+                    class: coerceString(interpreted.payload.class)
+                };
+            }
+            return {
+                success: false,
+                error: coerceString(interpreted.payload.error) ?? interpreted.error ?? `Actor not found: ${actorName}`
+            };
         }
         catch (err) {
             return { error: `Failed to get actor: ${err}` };

package/dist/resources/assets.js

@@ -1,3 +1,4 @@
+import { coerceBoolean, coerceString, interpretStandardResult } from '../utils/result-helpers.js';
 export class AssetResources {
     bridge;
     constructor(bridge) {
@@ -167,53 +168,45 @@ except Exception as e:
     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) {
-                        // Map folders and assets to a clear response
-                        const foldersArr = Array.isArray(parsed.folders_list) ? parsed.folders_list.map((f) => ({
-                            Name: f.n,
-                            Path: f.p,
-                            Class: 'Folder',
-                            isFolder: true
-                        })) : [];
-                        const assetsArr = Array.isArray(parsed.assets) ? parsed.assets.map((a) => ({
-                            Name: a.n,
-                            Path: a.p,
-                            Class: a.c || 'Asset',
-                            isFolder: false
-                        })) : [];
-                        const total = foldersArr.length + assetsArr.length;
-                        const summary = {
-                            total,
-                            folders: foldersArr.length,
-                            assets: assetsArr.length
-                        };
-                        return {
-                            success: true,
-                            path: parsed.path || this.normalizeDir(dir),
-                            summary,
-                            foldersList: foldersArr,
-                            assets: assetsArr,
-                            count: total,
-                            note: `Immediate children of ${parsed.path || this.normalizeDir(dir)}: ${foldersArr.length} folder(s), ${assetsArr.length} asset(s)`,
-                            method: 'asset_registry_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) {
@@ -247,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,25 +31,17 @@ 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 };
@@ -66,25 +52,14 @@ export class LevelResources {
         try {
             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;
 }