unreal-engine-mcp-server 0.3.1 → 0.4.3

package/dist/tools/foliage.js

@@ -1,3 +1,4 @@
+import { bestEffortInterpretedText, coerceBoolean, coerceNumber, coerceString, interpretStandardResult } from '../utils/result-helpers.js';
 export class FoliageTools {
     bridge;
     constructor(bridge) {
@@ -190,36 +191,36 @@ except Exception as e:
 print('RESULT:' + json.dumps(res))
 `.trim();
         const pyResp = await this.bridge.executePython(py);
-        let out = '';
-        if (pyResp?.LogOutput && Array.isArray(pyResp.LogOutput))
-            out = pyResp.LogOutput.map((l) => l.Output || '').join('');
-        else if (typeof pyResp === 'string')
-            out = pyResp;
-        else
-            out = JSON.stringify(pyResp);
-        const m = out.match(/RESULT:({.*})/);
-        if (m) {
-            try {
-                const parsed = JSON.parse(m[1]);
-                if (!parsed.success) {
-                    return { success: false, error: parsed.note || 'Add foliage type failed' };
-                }
-                return {
-                    success: true,
-                    created: parsed.created,
-                    exists: parsed.exists_after,
-                    method: parsed.method,
-                    assetPath: parsed.asset_path,
-                    usedMesh: parsed.used_mesh,
-                    note: parsed.note,
-                    message: parsed.exists_after ? `Foliage type '${name}' ready (${parsed.method || 'Unknown'})` : `Created foliage '${name}' but verification did not find it yet`
-                };
-            }
-            catch {
-                return { success: false, error: 'Failed to parse Python result' };
-            }
-        }
-        return { success: false, error: 'No parseable result from Python' };
+        const interpreted = interpretStandardResult(pyResp, {
+            successMessage: `Foliage type '${name}' processed`,
+            failureMessage: 'Add foliage type failed'
+        });
+        if (!interpreted.success) {
+            return {
+                success: false,
+                error: coerceString(interpreted.payload.note) ?? interpreted.error ?? 'Add foliage type failed',
+                note: coerceString(interpreted.payload.note) ?? bestEffortInterpretedText(interpreted)
+            };
+        }
+        const payload = interpreted.payload;
+        const created = coerceBoolean(payload.created, false) ?? false;
+        const exists = coerceBoolean(payload.exists_after, false) ?? created;
+        const method = coerceString(payload.method) ?? 'Unknown';
+        const assetPath = coerceString(payload.asset_path);
+        const usedMesh = coerceString(payload.used_mesh);
+        const note = coerceString(payload.note);
+        return {
+            success: true,
+            created,
+            exists,
+            method,
+            assetPath,
+            usedMesh,
+            note,
+            message: exists
+                ? `Foliage type '${name}' ready (${method})`
+                : `Created foliage '${name}' but verification did not find it yet`
+        };
     }
     // Paint foliage by placing HISM instances (editor-only)
     async paintFoliage(params) {
@@ -255,26 +256,34 @@ px, py, pz = ${pos[0]}, ${pos[1]}, ${pos[2]}
 radius = float(${brush}) / 2.0
 
 try:
-    actor_sub = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-    all_actors = actor_sub.get_all_level_actors() if actor_sub else []
+  actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
+  if not actor_subsystem:
+    raise RuntimeError('EditorActorSubsystem unavailable. Enable Editor Scripting Utilities plugin.')
 
-    # Find or create a container actor
-    label = f"FoliageContainer_{foliage_type_name}"
-    container = None
-    for a in all_actors:
-        try:
-            if a.get_actor_label() == label:
-                container = a
-                break
-        except Exception:
-            pass
+  all_actors = actor_subsystem.get_all_level_actors()
+
+  # Find or create a container actor using modern EditorActorSubsystem
+  label = f"FoliageContainer_{foliage_type_name}"
+  container = None
+  for a in all_actors:
+    try:
+      if a and a.get_actor_label() == label:
+        container = a
+        break
+    except Exception:
+      pass
+
+  if not container:
+    container = actor_subsystem.spawn_actor_from_class(
+      unreal.StaticMeshActor,
+      unreal.Vector(px, py, pz)
+    )
     if not container:
-        # Spawn actor that can hold components
-        container = unreal.EditorLevelLibrary.spawn_actor_from_class(unreal.StaticMeshActor, unreal.Vector(px, py, pz))
-        try:
-            container.set_actor_label(label)
-        except Exception:
-            pass
+      raise RuntimeError('Failed to spawn foliage container actor via EditorActorSubsystem')
+    try:
+      container.set_actor_label(label)
+    except Exception:
+      pass
 
     # Resolve mesh from FoliageType asset
     mesh = None
@@ -302,12 +311,12 @@ try:
         r = random.random() * radius
         x, y, z = px + math.cos(ang) * r, py + math.sin(ang) * r, pz
         try:
-            # Spawn static mesh actor at position
-            inst_actor = unreal.EditorLevelLibrary.spawn_actor_from_class(
-                unreal.StaticMeshActor, 
-                unreal.Vector(x, y, z),
-                unreal.Rotator(0, random.random()*360.0, 0)
-            )
+      # Spawn static mesh actor at position using modern subsystem
+      inst_actor = actor_subsystem.spawn_actor_from_class(
+        unreal.StaticMeshActor,
+        unreal.Vector(x, y, z),
+        unreal.Rotator(0, random.random()*360.0, 0)
+      )
             if inst_actor and mesh:
                 # Set mesh on the actor's component
                 try:
@@ -334,35 +343,32 @@ except Exception as e:
 print('RESULT:' + json.dumps(res))
 `.trim();
         const pyResp = await this.bridge.executePython(py);
-        let out = '';
-        if (pyResp?.LogOutput && Array.isArray(pyResp.LogOutput))
-            out = pyResp.LogOutput.map((l) => l.Output || '').join('');
-        else if (typeof pyResp === 'string')
-            out = pyResp;
-        else
-            out = JSON.stringify(pyResp);
-        const m = out.match(/RESULT:({.*})/);
-        if (m) {
-            try {
-                const parsed = JSON.parse(m[1]);
-                if (!parsed.success) {
-                    return { success: false, error: parsed.note || 'Paint foliage failed' };
-                }
-                return {
-                    success: true,
-                    added: parsed.added,
-                    actor: parsed.actor,
-                    component: parsed.component,
-                    usedMesh: parsed.used_mesh,
-                    note: parsed.note,
-                    message: `Painted ${parsed.added} instances for '${foliageType}' around (${pos[0]}, ${pos[1]}, ${pos[2]})`
-                };
-            }
-            catch {
-                return { success: false, error: 'Failed to parse Python result' };
-            }
-        }
-        return { success: false, error: 'No parseable result from Python' };
+        const interpreted = interpretStandardResult(pyResp, {
+            successMessage: `Painted foliage for '${foliageType}'`,
+            failureMessage: 'Paint foliage failed'
+        });
+        if (!interpreted.success) {
+            return {
+                success: false,
+                error: coerceString(interpreted.payload.note) ?? interpreted.error ?? 'Paint foliage failed',
+                note: coerceString(interpreted.payload.note) ?? bestEffortInterpretedText(interpreted)
+            };
+        }
+        const payload = interpreted.payload;
+        const added = coerceNumber(payload.added) ?? 0;
+        const actor = coerceString(payload.actor);
+        const component = coerceString(payload.component);
+        const usedMesh = coerceString(payload.used_mesh);
+        const note = coerceString(payload.note);
+        return {
+            success: true,
+            added,
+            actor,
+            component,
+            usedMesh,
+            note,
+            message: `Painted ${added} instances for '${foliageType}' around (${pos[0]}, ${pos[1]}, ${pos[2]})`
+        };
     }
     // Create instanced mesh
     async createInstancedMesh(params) {
@@ -379,9 +385,7 @@ print('RESULT:' + json.dumps(res))
         if (params.cullDistance !== undefined) {
             commands.push(`SetInstanceCullDistance ${params.name} ${params.cullDistance}`);
         }
-        for (const cmd of commands) {
-            await this.bridge.executeConsoleCommand(cmd);
-        }
+        await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: `Instanced mesh ${params.name} created with ${params.instances.length} instances` };
     }
     // Set foliage LOD
@@ -393,9 +397,7 @@ print('RESULT:' + json.dumps(res))
         if (params.screenSize) {
             commands.push(`SetFoliageLODScreenSize ${params.foliageType} ${params.screenSize.join(' ')}`);
         }
-        for (const cmd of commands) {
-            await this.bridge.executeConsoleCommand(cmd);
-        }
+        await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: 'Foliage LOD settings updated' };
     }
     // Create procedural foliage
@@ -412,9 +414,7 @@ print('RESULT:' + json.dumps(res))
             commands.push(`SetProceduralTileSize ${params.volumeName} ${params.tileSize}`);
         }
         commands.push(`GenerateProceduralFoliage ${params.volumeName}`);
-        for (const cmd of commands) {
-            await this.bridge.executeConsoleCommand(cmd);
-        }
+        await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: `Procedural foliage volume ${params.volumeName} created` };
     }
     // Set foliage collision
@@ -429,9 +429,7 @@ print('RESULT:' + json.dumps(res))
         if (params.generateOverlapEvents !== undefined) {
             commands.push(`SetFoliageOverlapEvents ${params.foliageType} ${params.generateOverlapEvents}`);
         }
-        for (const cmd of commands) {
-            await this.bridge.executeConsoleCommand(cmd);
-        }
+        await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: 'Foliage collision settings updated' };
     }
     // Create grass system
@@ -449,9 +447,7 @@ print('RESULT:' + json.dumps(res))
         if (params.windSpeed !== undefined) {
             commands.push(`SetGrassWindSpeed ${params.name} ${params.windSpeed}`);
         }
-        for (const cmd of commands) {
-            await this.bridge.executeConsoleCommand(cmd);
-        }
+        await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: `Grass system ${params.name} created` };
     }
     // Remove foliage instances
@@ -483,9 +479,7 @@ print('RESULT:' + json.dumps(res))
             commands.push(`UpdateFoliageMesh ${params.foliageType} ${params.newMeshPath}`);
         }
         commands.push(`RefreshFoliage ${params.foliageType}`);
-        for (const cmd of commands) {
-            await this.bridge.executeConsoleCommand(cmd);
-        }
+        await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: 'Foliage instances updated' };
     }
     // Create foliage spawner
@@ -497,9 +491,7 @@ print('RESULT:' + json.dumps(res))
                 commands.push(`AddFoliageExclusionArea ${params.name} ${area.join(' ')}`);
             }
         }
-        for (const cmd of commands) {
-            await this.bridge.executeConsoleCommand(cmd);
-        }
+        await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: `Foliage spawner ${params.name} created` };
     }
     // Optimize foliage
@@ -516,9 +508,7 @@ print('RESULT:' + json.dumps(res))
             commands.push('OptimizeFoliageDrawCalls');
         }
         commands.push('RebuildFoliageTree');
-        for (const cmd of commands) {
-            await this.bridge.executeConsoleCommand(cmd);
-        }
+        await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: 'Foliage optimized' };
     }
 }

package/dist/tools/introspection.js

@@ -1,4 +1,5 @@
 import { Logger } from '../utils/logger.js';
+import { bestEffortInterpretedText, interpretStandardResult } from '../utils/result-helpers.js';
 export class IntrospectionTools {
     bridge;
     log = new Logger('IntrospectionTools');
@@ -31,33 +32,30 @@ export class IntrospectionTools {
      * Parse Python execution result with better error handling
      */
     parsePythonResult(resp, operationName) {
-        let out = '';
-        if (resp?.LogOutput && Array.isArray(resp.LogOutput)) {
-            out = resp.LogOutput.map((l) => l.Output || '').join('');
+        const interpreted = interpretStandardResult(resp, {
+            successMessage: `${operationName} succeeded`,
+            failureMessage: `${operationName} failed`
+        });
+        if (interpreted.success) {
+            return {
+                ...interpreted.payload,
+                success: true
+            };
         }
-        else if (typeof resp === 'string') {
-            out = resp;
+        const output = bestEffortInterpretedText(interpreted) ?? '';
+        if (output) {
+            this.log.error(`Failed to parse ${operationName} result: ${output}`);
         }
-        else {
-            out = JSON.stringify(resp);
-        }
-        const m = out.match(/RESULT:({.*})/);
-        if (m) {
-            try {
-                return JSON.parse(m[1]);
-            }
-            catch (e) {
-                this.log.error(`Failed to parse ${operationName} result: ${e}`);
-            }
-        }
-        // Check for common error patterns
-        if (out.includes('ModuleNotFoundError')) {
+        if (output.includes('ModuleNotFoundError')) {
             return { success: false, error: 'Reflection module not available.' };
         }
-        if (out.includes('AttributeError')) {
+        if (output.includes('AttributeError')) {
             return { success: false, error: 'Reflection API method not found. Check Unreal Engine version compatibility.' };
         }
-        return { success: false, error: `${operationName} did not return a valid result: ${out.substring(0, 200)}` };
+        return {
+            success: false,
+            error: `${interpreted.error ?? `${operationName} did not return a valid result`}: ${output.substring(0, 200)}`
+        };
     }
     /**
      * Convert Unreal property value to JavaScript-friendly format

package/dist/tools/landscape.d.ts

@@ -2,7 +2,6 @@ import { UnrealBridge } from '../unreal-bridge.js';
 export declare class LandscapeTools {
     private bridge;
     constructor(bridge: UnrealBridge);
-    private _executeCommand;
     createLandscape(params: {
         name: string;
         location?: [number, number, number];
@@ -16,7 +15,7 @@ export declare class LandscapeTools {
         runtimeGrid?: string;
         isSpatiallyLoaded?: boolean;
         dataLayers?: string[];
-    }): Promise<any>;
+    }): Promise<Record<string, unknown>>;
     sculptLandscape(_params: {
         landscapeName: string;
         tool: 'Sculpt' | 'Smooth' | 'Flatten' | 'Ramp' | 'Erosion' | 'Hydro' | 'Noise' | 'Retopologize';