unreal-engine-mcp-server 0.3.1 → 0.4.3

package/dist/tools/debug.d.ts

@@ -2,7 +2,6 @@ import { UnrealBridge } from '../unreal-bridge.js';
 export declare class DebugVisualizationTools {
     private bridge;
     constructor(bridge: UnrealBridge);
-    private _executeCommand;
     private pyDraw;
     drawDebugLine(params: {
         start: [number, number, number];
@@ -12,10 +11,17 @@ export declare class DebugVisualizationTools {
         thickness?: number;
     }): Promise<{
         success: boolean;
-        error?: undefined;
+        action: string;
+        warnings: string[] | undefined;
+        details: string[] | undefined;
+        rawOutput: string | undefined;
+        raw: unknown;
+        message?: string;
+        error?: string;
     } | {
         success: boolean;
         error: string;
+        action: string;
     }>;
     drawDebugBox(params: {
         center: [number, number, number];
@@ -26,10 +32,17 @@ export declare class DebugVisualizationTools {
         thickness?: number;
     }): Promise<{
         success: boolean;
-        error?: undefined;
+        action: string;
+        warnings: string[] | undefined;
+        details: string[] | undefined;
+        rawOutput: string | undefined;
+        raw: unknown;
+        message?: string;
+        error?: string;
     } | {
         success: boolean;
         error: string;
+        action: string;
     }>;
     drawDebugSphere(params: {
         center: [number, number, number];
@@ -40,10 +53,17 @@ export declare class DebugVisualizationTools {
         thickness?: number;
     }): Promise<{
         success: boolean;
-        error?: undefined;
+        action: string;
+        warnings: string[] | undefined;
+        details: string[] | undefined;
+        rawOutput: string | undefined;
+        raw: unknown;
+        message?: string;
+        error?: string;
     } | {
         success: boolean;
         error: string;
+        action: string;
     }>;
     drawDebugCapsule(params: {
         center: [number, number, number];
@@ -54,10 +74,17 @@ export declare class DebugVisualizationTools {
         duration?: number;
     }): Promise<{
         success: boolean;
-        error?: undefined;
+        action: string;
+        warnings: string[] | undefined;
+        details: string[] | undefined;
+        rawOutput: string | undefined;
+        raw: unknown;
+        message?: string;
+        error?: string;
     } | {
         success: boolean;
         error: string;
+        action: string;
     }>;
     drawDebugCone(params: {
         origin: [number, number, number];
@@ -70,10 +97,17 @@ export declare class DebugVisualizationTools {
         duration?: number;
     }): Promise<{
         success: boolean;
-        error?: undefined;
+        action: string;
+        warnings: string[] | undefined;
+        details: string[] | undefined;
+        rawOutput: string | undefined;
+        raw: unknown;
+        message?: string;
+        error?: string;
     } | {
         success: boolean;
         error: string;
+        action: string;
     }>;
     drawDebugString(params: {
         location: [number, number, number];
@@ -83,10 +117,17 @@ export declare class DebugVisualizationTools {
         fontSize?: number;
     }): Promise<{
         success: boolean;
-        error?: undefined;
+        action: string;
+        warnings: string[] | undefined;
+        details: string[] | undefined;
+        rawOutput: string | undefined;
+        raw: unknown;
+        message?: string;
+        error?: string;
     } | {
         success: boolean;
         error: string;
+        action: string;
     }>;
     drawDebugArrow(params: {
         start: [number, number, number];
@@ -97,10 +138,17 @@ export declare class DebugVisualizationTools {
         thickness?: number;
     }): Promise<{
         success: boolean;
-        error?: undefined;
+        action: string;
+        warnings: string[] | undefined;
+        details: string[] | undefined;
+        rawOutput: string | undefined;
+        raw: unknown;
+        message?: string;
+        error?: string;
     } | {
         success: boolean;
         error: string;
+        action: string;
     }>;
     drawDebugPoint(params: {
         location: [number, number, number];
@@ -109,10 +157,17 @@ export declare class DebugVisualizationTools {
         duration?: number;
     }): Promise<{
         success: boolean;
-        error?: undefined;
+        action: string;
+        warnings: string[] | undefined;
+        details: string[] | undefined;
+        rawOutput: string | undefined;
+        raw: unknown;
+        message?: string;
+        error?: string;
     } | {
         success: boolean;
         error: string;
+        action: string;
     }>;
     drawDebugCoordinateSystem(params: {
         location: [number, number, number];
@@ -132,10 +187,17 @@ export declare class DebugVisualizationTools {
         duration?: number;
     }): Promise<{
         success: boolean;
-        error?: undefined;
+        action: string;
+        warnings: string[] | undefined;
+        details: string[] | undefined;
+        rawOutput: string | undefined;
+        raw: unknown;
+        message?: string;
+        error?: string;
     } | {
         success: boolean;
         error: string;
+        action: string;
     }>;
     clearDebugDrawings(): Promise<any>;
     showCollision(params: {

package/dist/tools/debug.js

@@ -1,41 +1,87 @@
+import { bestEffortInterpretedText, coerceString, interpretStandardResult } from '../utils/result-helpers.js';
+import { parseStandardResult } from '../utils/python-output.js';
 export class DebugVisualizationTools {
     bridge;
     constructor(bridge) {
         this.bridge = bridge;
     }
-    // Execute console command (kept for legacy operations)
-    async _executeCommand(command) {
-        return this.bridge.httpCall('/remote/object/call', 'PUT', {
-            objectPath: '/Script/Engine.Default__KismetSystemLibrary',
-            functionName: 'ExecuteConsoleCommand',
-            parameters: {
-                WorldContextObject: null,
-                Command: command,
-                SpecificPlayer: null
-            },
-            generateTransaction: false
-        });
-    }
     // Helper to draw via Python SystemLibrary with the editor world
-    async pyDraw(scriptBody) {
+    async pyDraw(scriptBody, meta) {
+        const action = (meta?.action || 'debug_draw').replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+        const payloadObject = meta?.params ?? {};
+        const payloadJson = JSON.stringify(payloadObject).replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+        const indentedBody = scriptBody
+            .split(/\r?\n/)
+            .map(line => `    ${line}`)
+            .join('\n');
         const script = `
 import unreal
-# Use modern UnrealEditorSubsystem instead of deprecated EditorLevelLibrary
+import json
+
+payload = json.loads('${payloadJson}')
 ues = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-if ues:
-    world = ues.get_editor_world()
-else:
-    # Fallback to deprecated API if subsystem not available
-    world = unreal.EditorLevelLibrary.get_editor_world()
-${scriptBody}
+if not ues:
+    raise Exception('UnrealEditorSubsystem not available')
+world = ues.get_editor_world()
+if not world:
+    raise Exception('Editor world unavailable')
+try:
+${indentedBody}
+    print('DEBUG_DRAW:' + json.dumps({'action': '${action}', 'params': payload}))
+    print('RESULT:' + json.dumps({'success': True, 'action': '${action}', 'params': payload}))
+except Exception as e:
+    print('DEBUG_DRAW_ERROR:' + str(e))
+    print('RESULT:' + json.dumps({'success': False, 'action': '${action}', 'error': str(e)}))
 `.trim()
             .replace(/\r?\n/g, '\n');
         try {
-            await this.bridge.executePython(script);
-            return { success: true };
+            const response = await this.bridge.executePython(script);
+            let interpreted = interpretStandardResult(response, {
+                successMessage: `${action} executed`,
+                failureMessage: `${action} failed`
+            });
+            const parsed = parseStandardResult(response);
+            const parsedPayload = parsed.data ?? {};
+            const parsedSuccessValue = parsedPayload.success;
+            const normalizedSuccess = typeof parsedSuccessValue === 'string'
+                ? ['true', '1', 'yes'].includes(parsedSuccessValue.toLowerCase())
+                : parsedSuccessValue === true;
+            if (!interpreted.success && normalizedSuccess) {
+                interpreted = {
+                    ...interpreted,
+                    success: true,
+                    error: undefined,
+                    message: interpreted.message || `${action} executed`,
+                    payload: { ...parsedPayload }
+                };
+            }
+            const finalSuccess = interpreted.success || normalizedSuccess;
+            const resolvedAction = coerceString(interpreted.payload.action) ?? action;
+            const fallbackOutput = typeof parsed.text === 'string' ? parsed.text : '';
+            const rawOutput = bestEffortInterpretedText(interpreted) ?? (fallbackOutput ? fallbackOutput : undefined);
+            if (finalSuccess) {
+                return {
+                    ...interpreted.payload,
+                    success: true,
+                    action: resolvedAction,
+                    warnings: interpreted.warnings,
+                    details: interpreted.details,
+                    rawOutput,
+                    raw: parsed.raw ?? interpreted.raw
+                };
+            }
+            return {
+                success: false,
+                action: resolvedAction,
+                error: interpreted.error ?? `${resolvedAction} failed`,
+                warnings: interpreted.warnings,
+                details: interpreted.details,
+                rawOutput,
+                raw: parsed.raw ?? interpreted.raw
+            };
         }
         catch (e) {
-            return { success: false, error: String(e) };
+            return { success: false, error: String(e), action: meta?.action || 'debug_draw' };
         }
     }
     // Draw debug line using Python SystemLibrary
@@ -52,7 +98,16 @@ end = unreal.Vector(${ex}, ${ey}, ${ez})
 color = unreal.LinearColor(${sr}/255.0, ${sg}/255.0, ${sb}/255.0, ${sa}/255.0)
 unreal.SystemLibrary.draw_debug_line(world, start, end, color, ${duration}, ${thickness})
 `;
-        return this.pyDraw(script);
+        return this.pyDraw(script, {
+            action: 'debug_line',
+            params: {
+                start: params.start,
+                end: params.end,
+                color,
+                duration,
+                thickness
+            }
+        });
     }
     // Draw debug box using Python SystemLibrary
     async drawDebugBox(params) {
@@ -71,7 +126,17 @@ rot = unreal.Rotator(${rp}, ${ry}, ${rr})
 color = unreal.LinearColor(${cr}/255.0, ${cg}/255.0, ${cb}/255.0, ${ca}/255.0)
 unreal.SystemLibrary.draw_debug_box(world, center, extent, color, rot, ${duration}, ${thickness})
 `;
-        return this.pyDraw(script);
+        return this.pyDraw(script, {
+            action: 'debug_box',
+            params: {
+                center: params.center,
+                extent: params.extent,
+                rotation,
+                color,
+                duration,
+                thickness
+            }
+        });
     }
     // Draw debug sphere using Python SystemLibrary
     async drawDebugSphere(params) {
@@ -86,7 +151,17 @@ center = unreal.Vector(${cx}, ${cy}, ${cz})
 color = unreal.LinearColor(${cr}/255.0, ${cg}/255.0, ${cb}/255.0, ${ca}/255.0)
 unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segments}, color, ${duration}, ${thickness})
 `;
-        return this.pyDraw(script);
+        return this.pyDraw(script, {
+            action: 'debug_sphere',
+            params: {
+                center: params.center,
+                radius: params.radius,
+                segments,
+                color,
+                duration,
+                thickness
+            }
+        });
     }
     // The rest keep console-command fallbacks or editor helpers as before
     async drawDebugCapsule(params) {
@@ -97,7 +172,17 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
         const [rp, ry, rr] = rotation;
         const [cr, cg, cb, ca] = color;
         const script = `\ncenter = unreal.Vector(${cx}, ${cy}, ${cz})\nrot = unreal.Rotator(${rp}, ${ry}, ${rr})\ncolor = unreal.LinearColor(${cr}/255.0, ${cg}/255.0, ${cb}/255.0, ${ca}/255.0)\nunreal.SystemLibrary.draw_debug_capsule(world, center, ${params.halfHeight}, ${params.radius}, rot, color, ${duration}, 1.0)\n`;
-        return this.pyDraw(script);
+        return this.pyDraw(script, {
+            action: 'debug_capsule',
+            params: {
+                center: params.center,
+                halfHeight: params.halfHeight,
+                radius: params.radius,
+                rotation,
+                color,
+                duration
+            }
+        });
     }
     async drawDebugCone(params) {
         const color = params.color || [255, 0, 255, 255];
@@ -106,7 +191,19 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
         const [dx, dy, dz] = params.direction;
         const [cr, cg, cb, ca] = color;
         const script = `\norigin = unreal.Vector(${ox}, ${oy}, ${oz})\ndir = unreal.Vector(${dx}, ${dy}, ${dz})\ncolor = unreal.LinearColor(${cr}/255.0, ${cg}/255.0, ${cb}/255.0, ${ca}/255.0)\nunreal.SystemLibrary.draw_debug_cone(world, origin, dir, ${params.length}, ${params.angleWidth}, ${params.angleHeight}, ${params.numSides || 12}, color, ${duration}, 1.0)\n`;
-        return this.pyDraw(script);
+        return this.pyDraw(script, {
+            action: 'debug_cone',
+            params: {
+                origin: params.origin,
+                direction: params.direction,
+                length: params.length,
+                angleWidth: params.angleWidth,
+                angleHeight: params.angleHeight,
+                numSides: params.numSides || 12,
+                color,
+                duration
+            }
+        });
     }
     async drawDebugString(params) {
         const color = params.color || [255, 255, 255, 255];
@@ -114,7 +211,16 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
         const [x, y, z] = params.location;
         const [r, g, b, a] = color;
         const script = `\nloc = unreal.Vector(${x}, ${y}, ${z})\ncolor = unreal.LinearColor(${r}/255.0, ${g}/255.0, ${b}/255.0, ${a}/255.0)\nunreal.SystemLibrary.draw_debug_string(world, loc, "${params.text.replace(/"/g, '\\"')}", None, color, ${duration})\n`;
-        return this.pyDraw(script);
+        return this.pyDraw(script, {
+            action: 'debug_string',
+            params: {
+                location: params.location,
+                text: params.text,
+                color,
+                duration,
+                fontSize: params.fontSize
+            }
+        });
     }
     async drawDebugArrow(params) {
         const color = params.color || [0, 255, 255, 255];
@@ -124,7 +230,17 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
         const [ex, ey, ez] = params.end;
         const [r, g, b, a] = color;
         const script = `\nstart = unreal.Vector(${sx}, ${sy}, ${sz})\nend = unreal.Vector(${ex}, ${ey}, ${ez})\ncolor = unreal.LinearColor(${r}/255.0, ${g}/255.0, ${b}/255.0, ${a}/255.0)\nunreal.SystemLibrary.draw_debug_arrow(world, start, end, ${params.arrowSize || 10.0}, color, ${duration}, ${thickness})\n`;
-        return this.pyDraw(script);
+        return this.pyDraw(script, {
+            action: 'debug_arrow',
+            params: {
+                start: params.start,
+                end: params.end,
+                arrowSize: params.arrowSize || 10.0,
+                color,
+                duration,
+                thickness
+            }
+        });
     }
     async drawDebugPoint(params) {
         const size = params.size || 10.0;
@@ -133,7 +249,15 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
         const [x, y, z] = params.location;
         const [r, g, b, a] = color;
         const script = `\nloc = unreal.Vector(${x}, ${y}, ${z})\ncolor = unreal.LinearColor(${r}/255.0, ${g}/255.0, ${b}/255.0, ${a}/255.0)\nunreal.SystemLibrary.draw_debug_point(world, loc, ${size}, color, ${duration})\n`;
-        return this.pyDraw(script);
+        return this.pyDraw(script, {
+            action: 'debug_point',
+            params: {
+                location: params.location,
+                size,
+                color,
+                duration
+            }
+        });
     }
     async drawDebugCoordinateSystem(params) {
         const rotation = params.rotation || [0, 0, 0];
@@ -153,7 +277,19 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
         const [rp, ry, rr] = params.rotation;
         const [r, g, b, a] = color;
         const script = `\norigin = unreal.Vector(${ox}, ${oy}, ${oz})\nrot = unreal.Rotator(${rp}, ${ry}, ${rr})\ncolor = unreal.LinearColor(${r}/255.0, ${g}/255.0, ${b}/255.0, ${a}/255.0)\nunreal.SystemLibrary.draw_debug_frustum(world, origin, rot, ${params.fov}, ${aspectRatio}, ${nearPlane}, ${farPlane}, color, ${duration})\n`;
-        return this.pyDraw(script);
+        return this.pyDraw(script, {
+            action: 'debug_frustum',
+            params: {
+                origin: params.origin,
+                rotation: params.rotation,
+                fov: params.fov,
+                aspectRatio,
+                nearPlane,
+                farPlane,
+                color,
+                duration
+            }
+        });
     }
     async clearDebugDrawings() {
         return this.bridge.executeConsoleCommand('FlushPersistentDebugLines');
@@ -167,9 +303,7 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
         else {
             commands.push('show Collision 0');
         }
-        for (const cmd of commands) {
-            await this.bridge.executeConsoleCommand(cmd);
-        }
+        await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: `Collision visualization ${params.enabled ? 'enabled' : 'disabled'}` };
     }
     async showBounds(params) {

package/dist/tools/editor.d.ts

@@ -42,12 +42,19 @@ export declare class EditorTools {
     }>;
     buildLighting(): Promise<{
         success: boolean;
-        message: any;
+        message: string;
         error?: undefined;
+        details?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        details: string | undefined;
+        message?: undefined;
     } | {
         success: boolean;
-        error: any;
+        error: string;
         message?: undefined;
+        details?: undefined;
     }>;
     setViewportCamera(location?: {
         x: number;

package/dist/tools/editor.js

@@ -1,4 +1,5 @@
 import { toVec3Object, toRotObject } from '../utils/normalize.js';
+import { bestEffortInterpretedText, coerceString, interpretStandardResult } from '../utils/result-helpers.js';
 export class EditorTools {
     bridge;
     constructor(bridge) {
@@ -65,28 +66,13 @@ else:
     print('RESULT:' + json.dumps({'success': False, 'error': 'LevelEditorSubsystem not available'}))
         `.trim();
                 const resp = await this.bridge.executePython(pythonCmd);
-                const out = typeof resp === 'string' ? resp : JSON.stringify(resp);
-                const m = out.match(/RESULT:({.*})/);
-                if (m) {
-                    try {
-                        const parsed = JSON.parse(m[1]);
-                        if (parsed.success) {
-                            const method = parsed.method || 'LevelEditorSubsystem';
-                            return { success: true, message: `PIE started (via ${method})` };
-                        }
-                    }
-                    catch {
-                        try {
-                            // Fallback: handle non-JSON python dict-style output
-                            const sanitized = m[1].replace(/'/g, '"').replace(/\bTrue\b/g, 'true').replace(/\bFalse\b/g, 'false');
-                            const parsed = JSON.parse(sanitized);
-                            if (parsed.success) {
-                                const method = parsed.method || 'LevelEditorSubsystem';
-                                return { success: true, message: `PIE started (via ${method})` };
-                            }
-                        }
-                        catch { }
-                    }
+                const interpreted = interpretStandardResult(resp, {
+                    successMessage: 'PIE started',
+                    failureMessage: 'Failed to start PIE'
+                });
+                if (interpreted.success) {
+                    const method = coerceString(interpreted.payload.method) ?? 'LevelEditorSubsystem';
+                    return { success: true, message: `PIE started (via ${method})` };
                 }
                 // If not verified, fall through to fallback
             }
@@ -125,20 +111,18 @@ else:
     print('RESULT:' + json.dumps({'success': False, 'error': 'LevelEditorSubsystem not available'}))
         `.trim();
                 const resp = await this.bridge.executePython(pythonCmd);
-                const out = typeof resp === 'string' ? resp : JSON.stringify(resp);
-                const m = out.match(/RESULT:({.*})/);
-                if (m) {
-                    try {
-                        const parsed = JSON.parse(m[1].replace(/'/g, '"'));
-                        if (parsed.success) {
-                            const method = parsed.method || 'LevelEditorSubsystem';
-                            return { success: true, message: `PIE stopped via ${method}` };
-                        }
-                    }
-                    catch { }
+                const interpreted = interpretStandardResult(resp, {
+                    successMessage: 'PIE stopped successfully',
+                    failureMessage: 'Failed to stop PIE'
+                });
+                if (interpreted.success) {
+                    const method = coerceString(interpreted.payload.method) ?? 'LevelEditorSubsystem';
+                    return { success: true, message: `PIE stopped via ${method}` };
                 }
-                // Default success message if parsing fails
-                return { success: true, message: 'PIE stopped successfully' };
+                if (interpreted.error) {
+                    return { success: false, error: interpreted.error };
+                }
+                return { success: false, error: 'Failed to stop PIE' };
             }
             catch {
                 // Fallback to console command
@@ -193,16 +177,18 @@ except Exception as e:
     print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
 `.trim();
             const resp = await this.bridge.executePython(py);
-            const out = typeof resp === 'string' ? resp : JSON.stringify(resp);
-            const m = out.match(/RESULT:({.*})/);
-            if (m) {
-                try {
-                    const parsed = JSON.parse(m[1].replace(/'/g, '"'));
-                    return parsed.success ? { success: true, message: parsed.message } : { success: false, error: parsed.error };
-                }
-                catch { }
+            const interpreted = interpretStandardResult(resp, {
+                successMessage: 'Lighting build started',
+                failureMessage: 'Failed to build lighting'
+            });
+            if (interpreted.success) {
+                return { success: true, message: interpreted.message };
             }
-            return { success: true, message: 'Lighting build started' };
+            return {
+                success: false,
+                error: interpreted.error ?? 'Failed to build lighting',
+                details: bestEffortInterpretedText(interpreted)
+            };
         }
         catch (err) {
             return { success: false, error: `Failed to build lighting: ${err}` };

package/dist/tools/foliage.d.ts

@@ -14,22 +14,32 @@ export declare class FoliageTools {
         groundSlope?: number;
     }): Promise<{
         success: boolean;
-        error: any;
+        error: string;
+        note?: undefined;
+        created?: undefined;
+        exists?: undefined;
+        method?: undefined;
+        assetPath?: undefined;
+        usedMesh?: undefined;
+        message?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        note: string | undefined;
         created?: undefined;
         exists?: undefined;
         method?: undefined;
         assetPath?: undefined;
         usedMesh?: undefined;
-        note?: undefined;
         message?: undefined;
     } | {
         success: boolean;
-        created: any;
-        exists: any;
-        method: any;
-        assetPath: any;
-        usedMesh: any;
-        note: any;
+        created: boolean;
+        exists: boolean;
+        method: string;
+        assetPath: string | undefined;
+        usedMesh: string | undefined;
+        note: string | undefined;
         message: string;
         error?: undefined;
     }>;
@@ -41,20 +51,29 @@ export declare class FoliageTools {
         eraseMode?: boolean;
     }): Promise<{
         success: boolean;
-        error: any;
+        error: string;
+        note?: undefined;
+        added?: undefined;
+        actor?: undefined;
+        component?: undefined;
+        usedMesh?: undefined;
+        message?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        note: string | undefined;
         added?: undefined;
         actor?: undefined;
         component?: undefined;
         usedMesh?: undefined;
-        note?: undefined;
         message?: undefined;
     } | {
         success: boolean;
-        added: any;
-        actor: any;
-        component: any;
-        usedMesh: any;
-        note: any;
+        added: number;
+        actor: string | undefined;
+        component: string | undefined;
+        usedMesh: string | undefined;
+        note: string | undefined;
         message: string;
         error?: undefined;
     }>;