unreal-engine-mcp-server 0.4.7 → 0.5.0

package/dist/tools/editor.js

@@ -1,23 +1,17 @@
+import { BaseTool } from './base-tool.js';
 import { toVec3Object, toRotObject } from '../utils/normalize.js';
-import { bestEffortInterpretedText, coerceString, interpretStandardResult } from '../utils/result-helpers.js';
-export class EditorTools {
-    bridge;
-    constructor(bridge) {
-        this.bridge = bridge;
-    }
+import { DEFAULT_SCREENSHOT_RESOLUTION } from '../constants.js';
+export class EditorTools extends BaseTool {
+    cameraBookmarks = new Map();
+    editorPreferences = new Map();
+    activeRecording;
     async isInPIE() {
         try {
-            const pythonCmd = `
-import unreal
-les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
-if les:
-    print("PIE_STATE:" + str(les.is_in_play_in_editor()))
-else:
-    print("PIE_STATE:False")
-      `.trim();
-            const resp = await this.bridge.executePython(pythonCmd);
-            const out = typeof resp === 'string' ? resp : JSON.stringify(resp);
-            return out.includes('PIE_STATE:True');
+            const response = await this.sendAutomationRequest('check_pie_state', {}, { timeoutMs: 5000 });
+            if (response && response.success !== false) {
+                return response.isInPIE === true || response.result?.isInPIE === true;
+            }
+            return false;
         }
         catch {
             return false;
@@ -26,70 +20,26 @@ else:
     async ensureNotInPIE() {
         if (await this.isInPIE()) {
             await this.stopPlayInEditor();
-            // Wait a bit for PIE to fully stop
             await new Promise(resolve => setTimeout(resolve, 500));
         }
     }
-    async playInEditor() {
+    async playInEditor(timeoutMs = 30000) {
         try {
-            // Set tick rate to match UI play (60 fps for game mode)
-            await this.bridge.executeConsoleCommand('t.MaxFPS 60');
-            // Try Python first using the modern LevelEditorSubsystem
             try {
-                // Use LevelEditorSubsystem to play in the selected viewport (modern API)
-                const pythonCmd = `
-import unreal, time, json
-# Start PIE using LevelEditorSubsystem (modern approach)
-les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
-if les:
-    # Store initial state
-    was_playing = les.is_in_play_in_editor()
-    
-    # Request PIE in the current viewport
-    les.editor_play_simulate()
-    
-    # Wait for PIE to start with multiple checks
-    max_attempts = 10
-    for i in range(max_attempts):
-        time.sleep(0.2)  # Wait 200ms between checks
-        is_playing = les.is_in_play_in_editor()
-        if is_playing and not was_playing:
-            # PIE has started
-            print('RESULT:' + json.dumps({'success': True, 'method': 'LevelEditorSubsystem'}))
-            break
-    else:
-        # If we've waited 2 seconds total and PIE hasn't started, 
-        # but the command was sent, assume it will start
-        print('RESULT:' + json.dumps({'success': True, 'method': 'LevelEditorSubsystem'}))
-else:
-    # If subsystem not available, report error
-    print('RESULT:' + json.dumps({'success': False, 'error': 'LevelEditorSubsystem not available'}))
-        `.trim();
-                const resp = await this.bridge.executePython(pythonCmd);
-                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})` };
+                const response = await this.sendAutomationRequest('control_editor', { action: 'play' }, { timeoutMs });
+                if (response && response.success === true) {
+                    return { success: true, message: response.message || 'PIE started' };
                 }
-                // If not verified, fall through to fallback
+                return { success: false, error: response?.error || response?.message || 'Failed to start PIE' };
             }
             catch (err) {
-                // Log the error for debugging but continue
-                console.error('Python PIE start issue:', err);
+                if (err.message && /time.*out/i.test(err.message)) {
+                    return { success: false, error: `Timeout waiting for PIE to start: ${err.message}` };
+                }
+                await this.bridge.executeConsoleCommand('t.MaxFPS 60');
+                await this.bridge.executeConsoleCommand('PlayInViewport');
+                return { success: true, message: 'PIE start command sent' };
             }
-            // Fallback to console command which is more reliable
-            await this.bridge.executeConsoleCommand('PlayInViewport');
-            // Wait a moment and verify PIE started
-            await new Promise(resolve => setTimeout(resolve, 1000));
-            // Check if PIE is now active
-            const isPlaying = await this.isInPIE();
-            return {
-                success: true,
-                message: isPlaying ? 'PIE started successfully' : 'PIE start command sent (may take a moment)'
-            };
         }
         catch (err) {
             return { success: false, error: `Failed to start PIE: ${err}` };
@@ -97,35 +47,20 @@ else:
     }
     async stopPlayInEditor() {
         try {
-            // Try Python first using the modern LevelEditorSubsystem
             try {
-                const pythonCmd = `
-import unreal, time, json
-les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
-if les:
-    # Use correct method name for stopping PIE
-    les.editor_request_end_play()  # Modern API method
-    print('RESULT:' + json.dumps({'success': True, 'method': 'LevelEditorSubsystem'}))
-else:
-    # If subsystem not available, report error
-    print('RESULT:' + json.dumps({'success': False, 'error': 'LevelEditorSubsystem not available'}))
-        `.trim();
-                const resp = await this.bridge.executePython(pythonCmd);
-                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}` };
-                }
-                if (interpreted.error) {
-                    return { success: false, error: interpreted.error };
+                const response = await this.sendAutomationRequest('control_editor', { action: 'stop' }, { timeoutMs: 30000 });
+                if (response.success !== false) {
+                    return {
+                        success: true,
+                        message: response.message || 'PIE stopped successfully'
+                    };
                 }
-                return { success: false, error: 'Failed to stop PIE' };
+                return {
+                    success: false,
+                    error: response.error || response.message || 'Failed to stop PIE'
+                };
             }
-            catch {
-                // Fallback to console command
+            catch (_pluginErr) {
                 await this.bridge.executeConsoleCommand('stop');
                 return { success: true, message: 'PIE stopped via console command' };
             }
@@ -136,69 +71,44 @@ else:
     }
     async pausePlayInEditor() {
         try {
-            // Pause/Resume PIE
-            await this.bridge.httpCall('/remote/object/call', 'PUT', {
-                objectPath: '/Script/Engine.Default__KismetSystemLibrary',
-                functionName: 'ExecuteConsoleCommand',
-                parameters: {
-                    WorldContextObject: null,
-                    Command: 'pause',
-                    SpecificPlayer: null
-                },
-                generateTransaction: false
-            });
+            await this.bridge.executeConsoleCommand('pause');
             return { success: true, message: 'PIE paused/resumed' };
         }
         catch (err) {
             return { success: false, error: `Failed to pause PIE: ${err}` };
         }
     }
-    // Alias for consistency with naming convention
     async pauseInEditor() {
         return this.pausePlayInEditor();
     }
     async buildLighting() {
         try {
-            // Use modern LevelEditorSubsystem to build lighting
-            const py = `
-import unreal
-import json
-try:
-    # Use modern LevelEditorSubsystem API
-    les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
-    if les:
-        # build_light_maps(quality, with_reflection_captures)
-        les.build_light_maps(unreal.LightingBuildQuality.QUALITY_HIGH, True)
-        print('RESULT:' + json.dumps({'success': True, 'message': 'Lighting build started via LevelEditorSubsystem'}))
-    else:
-        # If subsystem not available, report error
-        print('RESULT:' + json.dumps({'success': False, 'error': 'LevelEditorSubsystem not available'}))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-            const resp = await this.bridge.executePython(py);
-            const interpreted = interpretStandardResult(resp, {
-                successMessage: 'Lighting build started',
-                failureMessage: 'Failed to build lighting'
-            });
-            if (interpreted.success) {
-                return { success: true, message: interpreted.message };
-            }
-            return {
-                success: false,
-                error: interpreted.error ?? 'Failed to build lighting',
-                details: bestEffortInterpretedText(interpreted)
-            };
+            await this.bridge.executeConsoleCommand('BuildLighting');
+            return { success: true, message: 'Lighting build started' };
         }
         catch (err) {
             return { success: false, error: `Failed to build lighting: ${err}` };
         }
     }
+    async getViewportCameraInfo() {
+        try {
+            const resp = await this.sendAutomationRequest('control_editor', { action: 'get_camera' }, { timeoutMs: 3000 });
+            const result = resp?.result ?? resp;
+            const loc = result?.location ?? result?.camera?.location;
+            const rot = result?.rotation ?? result?.camera?.rotation;
+            const locArr = Array.isArray(loc) && loc.length === 3 ? [Number(loc[0]) || 0, Number(loc[1]) || 0, Number(loc[2]) || 0] : undefined;
+            const rotArr = Array.isArray(rot) && rot.length === 3 ? [Number(rot[0]) || 0, Number(rot[1]) || 0, Number(rot[2]) || 0] : undefined;
+            if (resp && resp.success !== false && locArr && rotArr) {
+                return { success: true, location: locArr, rotation: rotArr };
+            }
+            return { success: false, error: 'Failed to get camera information' };
+        }
+        catch (err) {
+            return { success: false, error: `Camera query failed: ${err}` };
+        }
+    }
     async setViewportCamera(location, rotation) {
-        // Special handling for when both location and rotation are missing/invalid
-        // Allow rotation-only updates
         if (location === null) {
-            // Explicit null is not allowed for location
             throw new Error('Invalid location: null is not allowed');
         }
         if (location !== undefined && location !== null) {
@@ -206,14 +116,12 @@ except Exception as e:
             if (!locObj) {
                 throw new Error('Invalid location: must be {x,y,z} or [x,y,z]');
             }
-            // Clamp extreme values to reasonable limits for Unreal Engine
-            const MAX_COORD = 1000000; // 1 million units is a reasonable max for UE
+            const MAX_COORD = 1000000;
             locObj.x = Math.max(-MAX_COORD, Math.min(MAX_COORD, locObj.x));
             locObj.y = Math.max(-MAX_COORD, Math.min(MAX_COORD, locObj.y));
             locObj.z = Math.max(-MAX_COORD, Math.min(MAX_COORD, locObj.z));
             location = locObj;
         }
-        // Validate rotation if provided
         if (rotation !== undefined) {
             if (rotation === null) {
                 throw new Error('Invalid rotation: null is not allowed');
@@ -222,107 +130,29 @@ except Exception as e:
             if (!rotObj) {
                 throw new Error('Invalid rotation: must be {pitch,yaw,roll} or [pitch,yaw,roll]');
             }
-            // Normalize rotation values to 0-360 range
             rotObj.pitch = ((rotObj.pitch % 360) + 360) % 360;
             rotObj.yaw = ((rotObj.yaw % 360) + 360) % 360;
             rotObj.roll = ((rotObj.roll % 360) + 360) % 360;
             rotation = rotObj;
         }
         try {
-            // Try Python for actual viewport camera positioning
-            // Only proceed if we have a valid location
-            if (location) {
-                try {
-                    const rot = rotation || { pitch: 0, yaw: 0, roll: 0 };
-                    const pythonCmd = `
-import unreal
-# Use UnrealEditorSubsystem instead of deprecated EditorLevelLibrary
-ues = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
-location = unreal.Vector(${location.x}, ${location.y}, ${location.z})
-rotation = unreal.Rotator(${rot.pitch}, ${rot.yaw}, ${rot.roll})
-if ues:
-    ues.set_level_viewport_camera_info(location, rotation)
-    # Invalidate viewports to ensure visual update
-    try:
-        if les:
-            les.editor_invalidate_viewports()
-    except Exception:
-        pass
-          `.trim();
-                    await this.bridge.executePython(pythonCmd);
-                    return {
-                        success: true,
-                        message: 'Viewport camera positioned via UnrealEditorSubsystem'
-                    };
-                }
-                catch {
-                    // Fallback to camera speed control
-                    await this.bridge.executeConsoleCommand('camspeed 4');
-                    return {
-                        success: true,
-                        message: 'Camera speed set. Use debug camera (toggledebugcamera) for manual positioning'
-                    };
-                }
-            }
-            else if (rotation) {
-                // Only rotation provided, try to set just rotation
-                try {
-                    const pythonCmd = `
-import unreal
-# Use UnrealEditorSubsystem to read/write viewport camera
-ues = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
-rotation = unreal.Rotator(${rotation.pitch}, ${rotation.yaw}, ${rotation.roll})
-if ues:
-    info = ues.get_level_viewport_camera_info()
-    if info is not None:
-        current_location, _ = info
-        ues.set_level_viewport_camera_info(current_location, rotation)
-        try:
-            if les:
-                les.editor_invalidate_viewports()
-        except Exception:
-            pass
-          `.trim();
-                    await this.bridge.executePython(pythonCmd);
-                    return {
-                        success: true,
-                        message: 'Viewport camera rotation set via UnrealEditorSubsystem'
-                    };
-                }
-                catch {
-                    // Fallback
-                    return {
-                        success: true,
-                        message: 'Camera rotation update attempted'
-                    };
-                }
-            }
-            else {
-                // Neither location nor rotation provided - this is valid, just no-op
-                return {
-                    success: true,
-                    message: 'No camera changes requested'
-                };
+            const resp = await this.sendAutomationRequest('control_editor', {
+                action: 'set_camera',
+                location: location,
+                rotation: rotation
+            }, { timeoutMs: 10000 });
+            if (resp && resp.success === true) {
+                return { success: true, message: resp.message || 'Camera set', location, rotation };
             }
+            return { success: false, error: resp?.error || resp?.message || 'Failed to set camera' };
         }
         catch (err) {
-            return { success: false, error: `Failed to set camera: ${err}` };
+            return { success: false, error: `Camera control failed: ${err}` };
         }
     }
     async setCameraSpeed(speed) {
         try {
-            await this.bridge.httpCall('/remote/object/call', 'PUT', {
-                objectPath: '/Script/Engine.Default__KismetSystemLibrary',
-                functionName: 'ExecuteConsoleCommand',
-                parameters: {
-                    WorldContextObject: null,
-                    Command: `camspeed ${speed}`,
-                    SpecificPlayer: null
-                },
-                generateTransaction: false
-            });
+            await this.bridge.executeConsoleCommand(`camspeed ${speed}`);
             return { success: true, message: `Camera speed set to ${speed}` };
         }
         catch (err) {
@@ -331,21 +161,186 @@ if ues:
     }
     async setFOV(fov) {
         try {
-            await this.bridge.httpCall('/remote/object/call', 'PUT', {
-                objectPath: '/Script/Engine.Default__KismetSystemLibrary',
-                functionName: 'ExecuteConsoleCommand',
-                parameters: {
-                    WorldContextObject: null,
-                    Command: `fov ${fov}`,
-                    SpecificPlayer: null
-                },
-                generateTransaction: false
-            });
+            await this.bridge.executeConsoleCommand(`fov ${fov}`);
             return { success: true, message: `FOV set to ${fov}` };
         }
         catch (err) {
             return { success: false, error: `Failed to set FOV: ${err}` };
         }
     }
+    async takeScreenshot(filename, resolution) {
+        try {
+            if (resolution && !/^\d+x\d+$/.test(resolution)) {
+                return { success: false, error: 'Invalid resolution format. Use WxH (e.g. 1920x1080)' };
+            }
+            const sanitizedFilename = filename ? filename.replace(/[<>:*?"|]/g, '_') : `Screenshot_${Date.now()}`;
+            const resString = resolution || DEFAULT_SCREENSHOT_RESOLUTION;
+            const command = filename ? `highresshot ${resString} filename="${sanitizedFilename}"` : 'shot';
+            await this.bridge.executeConsoleCommand(command);
+            return {
+                success: true,
+                message: `Screenshot captured: ${sanitizedFilename}`,
+                filename: sanitizedFilename,
+                command
+            };
+        }
+        catch (err) {
+            return { success: false, error: `Failed to take screenshot: ${err}` };
+        }
+    }
+    async resumePlayInEditor() {
+        try {
+            await this.bridge.executeConsoleCommand('pause');
+            return {
+                success: true,
+                message: 'PIE resume toggled via pause command'
+            };
+        }
+        catch (err) {
+            return { success: false, error: `Failed to resume PIE: ${err}` };
+        }
+    }
+    async stepPIEFrame(steps = 1) {
+        const clampedSteps = Number.isFinite(steps) ? Math.max(1, Math.floor(steps)) : 1;
+        try {
+            for (let index = 0; index < clampedSteps; index += 1) {
+                await this.bridge.executeConsoleCommand('Step=1');
+            }
+            return {
+                success: true,
+                message: `Advanced PIE by ${clampedSteps} frame(s)`,
+                steps: clampedSteps
+            };
+        }
+        catch (err) {
+            return { success: false, error: `Failed to step PIE: ${err}` };
+        }
+    }
+    async startRecording(options) {
+        const startedAt = Date.now();
+        this.activeRecording = {
+            name: typeof options?.filename === 'string' ? options.filename.trim() : undefined,
+            options: options ? { ...options } : undefined,
+            startedAt
+        };
+        return {
+            success: true,
+            message: 'Recording session started',
+            recording: {
+                name: this.activeRecording.name,
+                startedAt,
+                options: this.activeRecording.options
+            }
+        };
+    }
+    async stopRecording() {
+        if (!this.activeRecording) {
+            return {
+                success: true,
+                message: 'No active recording session to stop'
+            };
+        }
+        const stoppedRecording = this.activeRecording;
+        this.activeRecording = undefined;
+        return {
+            success: true,
+            message: 'Recording session stopped',
+            recording: stoppedRecording
+        };
+    }
+    async createCameraBookmark(name) {
+        const trimmedName = name.trim();
+        if (!trimmedName) {
+            return { success: false, error: 'bookmarkName is required' };
+        }
+        const cameraInfo = await this.getViewportCameraInfo();
+        if (!cameraInfo.success || !cameraInfo.location || !cameraInfo.rotation) {
+            return {
+                success: false,
+                error: cameraInfo.error || 'Failed to capture viewport camera'
+            };
+        }
+        this.cameraBookmarks.set(trimmedName, {
+            location: cameraInfo.location,
+            rotation: cameraInfo.rotation,
+            savedAt: Date.now()
+        });
+        return {
+            success: true,
+            message: `Bookmark '${trimmedName}' saved`,
+            bookmark: {
+                name: trimmedName,
+                location: cameraInfo.location,
+                rotation: cameraInfo.rotation
+            }
+        };
+    }
+    async jumpToCameraBookmark(name) {
+        const trimmedName = name.trim();
+        if (!trimmedName) {
+            return { success: false, error: 'bookmarkName is required' };
+        }
+        const bookmark = this.cameraBookmarks.get(trimmedName);
+        if (!bookmark) {
+            return {
+                success: false,
+                error: `Bookmark '${trimmedName}' not found`
+            };
+        }
+        await this.setViewportCamera({ x: bookmark.location[0], y: bookmark.location[1], z: bookmark.location[2] }, { pitch: bookmark.rotation[0], yaw: bookmark.rotation[1], roll: bookmark.rotation[2] });
+        return {
+            success: true,
+            message: `Jumped to bookmark '${trimmedName}'`
+        };
+    }
+    async setEditorPreferences(category, preferences) {
+        const resolvedCategory = typeof category === 'string' && category.trim().length > 0 ? category.trim() : 'General';
+        const existing = this.editorPreferences.get(resolvedCategory) ?? {};
+        this.editorPreferences.set(resolvedCategory, { ...existing, ...preferences });
+        return {
+            success: true,
+            message: `Preferences stored for ${resolvedCategory}`,
+            preferences: this.editorPreferences.get(resolvedCategory)
+        };
+    }
+    async setViewportResolution(width, height) {
+        try {
+            const clampedWidth = Math.max(320, Math.min(7680, width));
+            const clampedHeight = Math.max(240, Math.min(4320, height));
+            const command = `r.SetRes ${clampedWidth}x${clampedHeight}`;
+            await this.bridge.executeConsoleCommand(command);
+            return {
+                success: true,
+                message: `Viewport resolution set to ${clampedWidth}x${clampedHeight}`,
+                width: clampedWidth,
+                height: clampedHeight
+            };
+        }
+        catch (err) {
+            return { success: false, error: `Failed to set viewport resolution: ${err}` };
+        }
+    }
+    async executeConsoleCommand(command) {
+        try {
+            if (!command || typeof command !== 'string') {
+                return { success: false, error: 'Invalid command: must be a non-empty string' };
+            }
+            if (command.length > 1000) {
+                return {
+                    success: false,
+                    error: `Command too long (${command.length} chars). Maximum is 1000 characters.`
+                };
+            }
+            const res = await this.bridge.executeConsoleCommand(command);
+            return {
+                success: true,
+                message: `Console command executed: ${command}`,
+                output: res
+            };
+        }
+        catch (err) {
+            return { success: false, error: `Failed to execute console command: ${err}` };
+        }
+    }
 }
 //# sourceMappingURL=editor.js.map

package/dist/tools/engine.d.ts

@@ -1,8 +1,10 @@
 import { UnrealBridge } from '../unreal-bridge.js';
+import { AutomationBridge } from '../automation/index.js';
 export declare class EngineTools {
-    private bridge;
+    private automationBridge?;
     private env;
-    constructor(bridge: UnrealBridge);
+    constructor(_bridge: UnrealBridge, automationBridge?: AutomationBridge | undefined);
+    setAutomationBridge(automationBridge?: AutomationBridge): void;
     launchEditor(params?: {
         editorExe?: string;
         projectPath?: string;
@@ -19,12 +21,16 @@ export declare class EngineTools {
     }>;
     quitEditor(): Promise<{
         success: boolean;
+        error: string;
         message: string;
-        error?: undefined;
     } | {
         success: boolean;
-        error: string;
+        error: any;
         message?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        error?: undefined;
     }>;
 }
 //# sourceMappingURL=engine.d.ts.map

package/dist/tools/engine.js

@@ -1,10 +1,13 @@
 import { loadEnv } from '../types/env.js';
 import { spawn } from 'child_process';
 export class EngineTools {
-    bridge;
+    automationBridge;
     env = loadEnv();
-    constructor(bridge) {
-        this.bridge = bridge;
+    constructor(_bridge, automationBridge) {
+        this.automationBridge = automationBridge;
+    }
+    setAutomationBridge(automationBridge) {
+        this.automationBridge = automationBridge;
     }
     async launchEditor(params) {
         const exe = params?.editorExe || this.env.UE_EDITOR_EXE;
@@ -23,9 +26,14 @@ export class EngineTools {
         }
     }
     async quitEditor() {
+        if (!this.automationBridge) {
+            return { success: false, error: 'AUTOMATION_BRIDGE_UNAVAILABLE', message: 'Automation bridge is not available for quit_editor' };
+        }
         try {
-            // Use Python SystemLibrary.quit_editor if available
-            await this.bridge.executePython('import unreal; unreal.SystemLibrary.quit_editor()');
+            const resp = await this.automationBridge.sendAutomationRequest('quit_editor', {});
+            if (resp && resp.success === false) {
+                return { success: false, error: resp.error || resp.message || 'Quit request failed' };
+            }
             return { success: true, message: 'Quit command sent' };
         }
         catch (err) {