unreal-engine-mcp-server 0.4.7 → 0.5.1

package/dist/tools/ui.js

@@ -1,228 +1,167 @@
 import { bestEffortInterpretedText, interpretStandardResult } from '../utils/result-helpers.js';
 export class UITools {
     bridge;
-    constructor(bridge) {
+    automationBridge;
+    constructor(bridge, automationBridge) {
         this.bridge = bridge;
+        this.automationBridge = automationBridge;
+    }
+    setAutomationBridge(automationBridge) {
+        this.automationBridge = automationBridge;
     }
-    // Create widget blueprint
     async createWidget(params) {
         const path = params.savePath || '/Game/UI/Widgets';
-        const py = `
-import unreal
-import json
-name = r"${params.name}"
-path = r"${path}"
-try:
-    asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
-    try:
-        factory = unreal.WidgetBlueprintFactory()
-    except Exception:
-        factory = None
-    if not factory:
-        print('RESULT:' + json.dumps({'success': False, 'error': 'WidgetBlueprintFactory unavailable'}))
-    else:
-        # Try setting parent_class in a version-tolerant way
-        try:
-            factory.parent_class = unreal.UserWidget
-        except Exception:
-            try:
-                factory.set_editor_property('parent_class', unreal.UserWidget)
-            except Exception:
-                pass
-        asset = asset_tools.create_asset(asset_name=name, package_path=path, asset_class=unreal.WidgetBlueprint, factory=factory)
-        if asset:
-            unreal.EditorAssetLibrary.save_asset(f"{path}/{name}")
-            print('RESULT:' + json.dumps({'success': True}))
-        else:
-            print('RESULT:' + json.dumps({'success': False, 'error': 'Failed to create WidgetBlueprint'}))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-        try {
-            const resp = await this.bridge.executePython(py);
-            const interpreted = interpretStandardResult(resp, {
-                successMessage: 'Widget blueprint created',
-                failureMessage: 'Failed to create WidgetBlueprint'
-            });
-            if (interpreted.success) {
-                return { success: true, message: interpreted.message };
+        if (this.automationBridge && typeof this.automationBridge.sendAutomationRequest === 'function') {
+            try {
+                const resp = await this.automationBridge.sendAutomationRequest('system_control', {
+                    action: 'create_widget',
+                    name: params.name,
+                    widgetType: params.type,
+                    savePath: path
+                });
+                if (resp && resp.success !== false) {
+                    const result = resp.result ?? resp;
+                    const resultObj = result && typeof result === 'object' ? result : undefined;
+                    const widgetPath = typeof resultObj?.widgetPath === 'string' ? resultObj.widgetPath : `${path}/${params.name}`;
+                    const message = resp.message || `Widget created at ${widgetPath}`;
+                    return {
+                        success: true,
+                        message,
+                        widgetPath,
+                        exists: Boolean(resultObj?.exists),
+                        ...(resultObj || {})
+                    };
+                }
             }
-            return {
-                success: false,
-                error: interpreted.error ?? 'Failed to create widget blueprint',
-                details: bestEffortInterpretedText(interpreted)
+            catch (error) {
+                console.warn('UITools.createWidget automation bridge request failed, falling back to editor function:', error);
+            }
+        }
+        try {
+            const payload = {
+                asset_name: params.name,
+                package_path: path,
+                factory_class: 'WidgetBlueprintFactory',
+                asset_class: 'unreal.WidgetBlueprint'
             };
+            const resp = await this.bridge.executeEditorFunction('CREATE_ASSET', payload);
+            const result = resp && typeof resp === 'object' ? (resp.result ?? resp) : resp;
+            if (result && (result.success === true || result.created === true || Boolean(result.path))) {
+                return { success: true, message: result.message ?? `Widget created at ${result.path ?? `${path}/${params.name}`}` };
+            }
+            if (result && result.success === false) {
+                return { success: false, error: result.error ?? result.message ?? 'Failed to create widget blueprint', details: result };
+            }
+            return { success: false, error: 'Failed to create widget blueprint' };
         }
         catch (e) {
             return { success: false, error: `Failed to create widget blueprint: ${e}` };
         }
     }
-    // Add widget component
-    async addWidgetComponent(params) {
-        const commands = [];
-        commands.push(`AddWidgetComponent ${params.widgetName} ${params.componentType} ${params.componentName}`);
-        if (params.slot) {
-            if (params.slot.position) {
-                commands.push(`SetWidgetPosition ${params.widgetName}.${params.componentName} ${params.slot.position.join(' ')}`);
-            }
-            if (params.slot.size) {
-                commands.push(`SetWidgetSize ${params.widgetName}.${params.componentName} ${params.slot.size.join(' ')}`);
-            }
-            if (params.slot.anchor) {
-                commands.push(`SetWidgetAnchor ${params.widgetName}.${params.componentName} ${params.slot.anchor.join(' ')}`);
-            }
-            if (params.slot.alignment) {
-                commands.push(`SetWidgetAlignment ${params.widgetName}.${params.componentName} ${params.slot.alignment.join(' ')}`);
-            }
-        }
-        await this.bridge.executeConsoleCommands(commands);
-        return { success: true, message: `Component ${params.componentName} added to widget` };
+    async showWidget(widgetPath) {
+        return this.addWidgetToViewport({ widgetClass: widgetPath });
     }
-    // Set text
-    async setWidgetText(params) {
-        const commands = [];
-        commands.push(`SetWidgetText ${params.widgetName}.${params.componentName} "${params.text}"`);
-        if (params.fontSize !== undefined) {
-            commands.push(`SetWidgetFontSize ${params.widgetName}.${params.componentName} ${params.fontSize}`);
+    async addWidgetComponent(_params) {
+        if (!this.automationBridge) {
+            throw new Error('Automation bridge required for widget component operations');
         }
-        if (params.color) {
-            commands.push(`SetWidgetTextColor ${params.widgetName}.${params.componentName} ${params.color.join(' ')}`);
+        try {
+            const response = await this.automationBridge.sendAutomationRequest('manage_ui', {
+                action: 'add_widget_child',
+                widgetPath: _params.widgetName,
+                childClass: _params.componentType,
+                parentName: _params.slot ? 'Root' : undefined,
+            });
+            return response.success
+                ? { success: true, message: response.message || 'Widget component added', ...(response.result || {}) }
+                : { success: false, error: response.error || response.message || 'Failed to add widget component' };
         }
-        if (params.fontFamily) {
-            commands.push(`SetWidgetFont ${params.widgetName}.${params.componentName} ${params.fontFamily}`);
+        catch (error) {
+            return { success: false, error: `Failed to add widget component: ${error instanceof Error ? error.message : String(error)}` };
         }
-        await this.bridge.executeConsoleCommands(commands);
-        return { success: true, message: 'Widget text updated' };
     }
-    // Set image
-    async setWidgetImage(params) {
-        const commands = [];
-        commands.push(`SetWidgetImage ${params.widgetName}.${params.componentName} ${params.imagePath}`);
-        if (params.tint) {
-            commands.push(`SetWidgetImageTint ${params.widgetName}.${params.componentName} ${params.tint.join(' ')}`);
+    async setWidgetText(_params) {
+        if (!this.automationBridge) {
+            throw new Error('Automation bridge required for setting widget text');
         }
-        if (params.sizeToContent !== undefined) {
-            commands.push(`SetWidgetSizeToContent ${params.widgetName}.${params.componentName} ${params.sizeToContent}`);
+        try {
+            const response = await this.automationBridge.sendAutomationRequest('system_control', {
+                subAction: 'set_widget_text',
+                key: _params.key,
+                value: _params.value
+            });
+            return response.success
+                ? { success: true, message: response.message || 'Widget text set', ...(response.result || {}) }
+                : { success: false, error: response.error || response.message || 'Failed to set widget text' };
+        }
+        catch (error) {
+            return { success: false, error: `Failed to set widget text: ${error instanceof Error ? error.message : String(error)}` };
         }
-        await this.bridge.executeConsoleCommands(commands);
-        return { success: true, message: 'Widget image updated' };
     }
-    // Create HUD
-    async createHUD(params) {
-        const commands = [];
-        commands.push(`CreateHUDClass ${params.name}`);
-        if (params.elements) {
-            for (const element of params.elements) {
-                const size = element.size || [100, 50];
-                commands.push(`AddHUDElement ${params.name} ${element.type} ${element.position.join(' ')} ${size.join(' ')}`);
-            }
+    async setWidgetImage(_params) {
+        if (!this.automationBridge) {
+            throw new Error('Automation bridge required for setting widget images');
+        }
+        try {
+            const response = await this.automationBridge.sendAutomationRequest('system_control', {
+                subAction: 'set_widget_image',
+                key: _params.key,
+                texturePath: _params.texturePath
+            });
+            return response.success
+                ? { success: true, message: response.message || 'Widget image set', ...(response.result || {}) }
+                : { success: false, error: response.error || response.message || 'Failed to set widget image' };
+        }
+        catch (error) {
+            return { success: false, error: `Failed to set widget image: ${error instanceof Error ? error.message : String(error)}` };
         }
-        await this.bridge.executeConsoleCommands(commands);
-        return { success: true, message: `HUD ${params.name} created` };
     }
-    // Show/Hide widget
-    async setWidgetVisibility(params) {
-        const playerIndex = params.playerIndex ?? 0;
-        const widgetName = params.widgetName?.trim();
-        if (!widgetName) {
-            return { success: false, error: 'widgetName is required' };
+    async createHUD(_params) {
+        if (!this.automationBridge) {
+            throw new Error('Automation bridge required for creating HUDs');
         }
-        const verifyScript = `
-import unreal, json
-name = r"${widgetName}"
-candidates = []
-if name.startswith('/Game/'):
-    candidates.append(name)
-else:
-    candidates.append(f"/Game/UI/Widgets/{name}")
-    candidates.append(f"/Game/{name}")
-
-found_path = ''
-for path in candidates:
-    if unreal.EditorAssetLibrary.does_asset_exist(path):
-        found_path = path
-        break
-
-print('RESULT:' + json.dumps({'success': bool(found_path), 'path': found_path, 'candidates': candidates}))
-`.trim();
-        const verify = await this.bridge.executePythonWithResult(verifyScript);
-        if (!verify?.success) {
-            return { success: false, error: `Widget asset not found for ${widgetName}` };
+        const widgetPath = _params.name.startsWith('/Game') ? _params.name : `/Game/UI/${_params.name}`;
+        try {
+            const response = await this.automationBridge.sendAutomationRequest('system_control', {
+                subAction: 'create_hud',
+                widgetPath: widgetPath
+            });
+            return response.success
+                ? { success: true, message: response.message || 'HUD created', widgetName: response.result?.widgetName, ...(response.result || {}) }
+                : { success: false, error: response.error || response.message || 'Failed to create HUD' };
+        }
+        catch (error) {
+            return { success: false, error: `Failed to create HUD: ${error instanceof Error ? error.message : String(error)}` };
         }
-        const command = params.visible
-            ? `ShowWidget ${widgetName} ${playerIndex}`
-            : `HideWidget ${widgetName} ${playerIndex}`;
-        const raw = await this.bridge.executeConsoleCommand(command);
-        const summary = this.bridge.summarizeConsoleCommand(command, raw);
-        return {
-            success: true,
-            message: params.visible ? `Widget ${widgetName} show command issued` : `Widget ${widgetName} hide command issued`,
-            command: summary.command,
-            output: summary.output || undefined,
-            logLines: summary.logLines?.length ? summary.logLines : undefined
-        };
     }
-    // Add widget to viewport
+    async setWidgetVisibility(params) {
+        if (!this.automationBridge)
+            return { success: false, error: 'NO_BRIDGE' };
+        const response = await this.automationBridge.sendAutomationRequest('system_control', {
+            subAction: 'set_widget_visibility',
+            key: params.key,
+            visible: params.visible
+        });
+        return response.success
+            ? { success: true, message: response.message || 'Widget visibility set', ...(response.result || {}) }
+            : { success: false, error: response.error || response.message || 'Failed to set widget visibility' };
+    }
+    async removeWidgetFromViewport(params) {
+        if (!this.automationBridge)
+            return { success: false, error: 'NO_BRIDGE' };
+        const response = await this.automationBridge.sendAutomationRequest('system_control', {
+            subAction: 'remove_widget_from_viewport',
+            key: params.key
+        });
+        return response.success
+            ? { success: true, message: response.message || 'Widget removed from viewport', ...(response.result || {}) }
+            : { success: false, error: response.error || response.message || 'Failed to remove widget from viewport' };
+    }
     async addWidgetToViewport(params) {
         const zOrder = params.zOrder ?? 0;
         const playerIndex = params.playerIndex ?? 0;
-        // Use Python API to create and add widget to viewport
-        const py = `
-import unreal
-import json
-widget_path = r"${params.widgetClass}"
-z_order = ${zOrder}
-player_index = ${playerIndex}
-try:
-    # Load the widget blueprint class
-    if not unreal.EditorAssetLibrary.does_asset_exist(widget_path):
-        print('RESULT:' + json.dumps({'success': False, 'error': f'Widget class not found: {widget_path}'}))
-    else:
-        widget_bp = unreal.EditorAssetLibrary.load_asset(widget_path)
-        if not widget_bp:
-            print('RESULT:' + json.dumps({'success': False, 'error': 'Failed to load widget blueprint'}))
-        else:
-            # Get the generated class from the widget blueprint
-            widget_class = widget_bp.generated_class() if hasattr(widget_bp, 'generated_class') else widget_bp
-            
-      # Get the world and player controller via modern subsystems
-      world = None
-      try:
-        world = unreal.EditorUtilityLibrary.get_editor_world()
-      except Exception:
-        pass
-
-      if not world:
-        editor_subsystem = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-        if editor_subsystem and hasattr(editor_subsystem, 'get_editor_world'):
-          world = editor_subsystem.get_editor_world()
-
-      if not world:
-        print('RESULT:' + json.dumps({'success': False, 'error': 'No editor world available. Start a PIE session or enable Editor Scripting Utilities.'}))
-            else:
-                # Try to get player controller
-                try:
-                    player_controller = unreal.GameplayStatics.get_player_controller(world, player_index)
-                except Exception:
-                    player_controller = None
-                
-                if not player_controller:
-                    # If no player controller in PIE, try to get the first one or create a dummy
-                    print('RESULT:' + json.dumps({'success': False, 'error': 'No player controller available. Run in PIE mode first.'}))
-                else:
-                    # Create the widget
-                    widget = unreal.WidgetBlueprintLibrary.create(world, widget_class, player_controller)
-                    if widget:
-                        # Add to viewport
-                        widget.add_to_viewport(z_order)
-                        print('RESULT:' + json.dumps({'success': True}))
-                    else:
-                        print('RESULT:' + json.dumps({'success': False, 'error': 'Failed to create widget instance'}))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
         try {
-            const resp = await this.bridge.executePython(py);
+            const resp = await this.bridge.executeEditorFunction('ADD_WIDGET_TO_VIEWPORT', { widget_path: params.widgetClass, z_order: zOrder, player_index: playerIndex });
             const interpreted = interpretStandardResult(resp, {
                 successMessage: `Widget added to viewport with z-order ${zOrder}`,
                 failureMessage: 'Failed to add widget to viewport'
@@ -230,23 +169,12 @@ except Exception as e:
             if (interpreted.success) {
                 return { success: true, message: interpreted.message };
             }
-            return {
-                success: false,
-                error: interpreted.error ?? 'Failed to add widget to viewport',
-                details: bestEffortInterpretedText(interpreted)
-            };
+            return { success: false, error: interpreted.error ?? 'Failed to add widget to viewport', details: bestEffortInterpretedText(interpreted) };
         }
         catch (e) {
             return { success: false, error: `Failed to add widget to viewport: ${e}` };
         }
     }
-    // Remove widget from viewport
-    async removeWidgetFromViewport(params) {
-        const playerIndex = params.playerIndex ?? 0;
-        const command = `RemoveWidgetFromViewport ${params.widgetName} ${playerIndex}`;
-        return this.bridge.executeConsoleCommand(command);
-    }
-    // Create menu
     async createMenu(params) {
         const commands = [];
         commands.push(`CreateMenuWidget ${params.name} ${params.menuType}`);
@@ -259,7 +187,6 @@ except Exception as e:
         await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: `Menu ${params.name} created` };
     }
-    // Set widget animation
     async createWidgetAnimation(params) {
         const commands = [];
         commands.push(`CreateWidgetAnimation ${params.widgetName} ${params.animationName} ${params.duration}`);
@@ -275,14 +202,12 @@ except Exception as e:
         await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: `Animation ${params.animationName} created` };
     }
-    // Play widget animation
     async playWidgetAnimation(params) {
         const playMode = params.playMode || 'Forward';
         const loops = params.loops ?? 1;
         const command = `PlayWidgetAnimation ${params.widgetName} ${params.animationName} ${playMode} ${loops}`;
         return this.bridge.executeConsoleCommand(command);
     }
-    // Set widget style
     async setWidgetStyle(params) {
         const commands = [];
         if (params.style.backgroundColor) {
@@ -303,12 +228,10 @@ except Exception as e:
         await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: 'Widget style updated' };
     }
-    // Bind widget event
     async bindWidgetEvent(params) {
         const command = `BindWidgetEvent ${params.widgetName}.${params.componentName} ${params.eventType} ${params.functionName}`;
         return this.bridge.executeConsoleCommand(command);
     }
-    // Set input mode
     async setInputMode(params) {
         const commands = [];
         commands.push(`SetInputMode ${params.mode}`);
@@ -321,13 +244,11 @@ except Exception as e:
         await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: `Input mode set to ${params.mode}` };
     }
-    // Create tooltip
     async createTooltip(params) {
         const delay = params.delay ?? 0.5;
         const command = `SetWidgetTooltip ${params.widgetName}.${params.componentName} "${params.text}" ${delay}`;
         return this.bridge.executeConsoleCommand(command);
     }
-    // Create drag and drop
     async setupDragDrop(params) {
         const commands = [];
         commands.push(`EnableDragDrop ${params.widgetName}.${params.componentName}`);
@@ -342,7 +263,6 @@ except Exception as e:
         await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: 'Drag and drop configured' };
     }
-    // Create notification
     async showNotification(params) {
         const duration = params.duration ?? 3.0;
         const type = params.type || 'Info';

package/dist/types/automation-responses.d.ts

@@ -0,0 +1,115 @@
+export interface AutomationResponse {
+    success: boolean;
+    message?: string;
+    error?: string | {
+        message: string;
+        code?: string;
+    };
+    result?: unknown;
+    warnings?: string[];
+    details?: unknown;
+    data?: unknown;
+    [key: string]: unknown;
+}
+export interface LevelResponse extends AutomationResponse {
+    levelPath?: string;
+    level?: string;
+    path?: string;
+    packagePath?: string;
+    objectPath?: string;
+    currentMap?: string;
+    currentMapPath?: string;
+    currentWorldLevels?: unknown[];
+    allMaps?: unknown[];
+    partitioned?: boolean;
+    streaming?: boolean;
+    loaded?: boolean;
+    visible?: boolean;
+    skipped?: boolean;
+    reason?: string;
+}
+export interface ActorResponse extends AutomationResponse {
+    actorName?: string;
+    actorLabel?: string;
+    actorPath?: string;
+    actors?: unknown[];
+    components?: unknown[];
+    location?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation?: {
+        pitch: number;
+        yaw: number;
+        roll: number;
+    };
+    scale?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    transform?: unknown;
+    tags?: string[];
+    properties?: Record<string, unknown>;
+    deleted?: boolean;
+    deletedCount?: number;
+}
+export interface AssetResponse extends AutomationResponse {
+    assetPath?: string;
+    asset?: string;
+    assets?: unknown[];
+    source?: string;
+    saved?: boolean;
+    metadata?: Record<string, unknown>;
+    tags?: string[];
+    graph?: Record<string, unknown[]>;
+}
+export interface EditorResponse extends AutomationResponse {
+    viewMode?: string;
+    fov?: number;
+    location?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation?: {
+        pitch: number;
+        yaw: number;
+        roll: number;
+    };
+    cameraSettings?: unknown;
+    camera?: {
+        location?: unknown;
+        rotation?: unknown;
+    };
+    resolution?: {
+        width: number;
+        height: number;
+    };
+    filename?: string;
+    filePath?: string;
+    isPlaying?: boolean;
+    isPaused?: boolean;
+    isInPIE?: boolean;
+    playSessionId?: string;
+    bookmarkName?: string;
+    bookmarks?: unknown[];
+    realtime?: boolean;
+}
+export interface SequenceResponse extends AutomationResponse {
+    sequencePath?: string;
+    sequence?: string;
+    bindingId?: string;
+    trackName?: string;
+    keyframe?: unknown;
+    frameNumber?: number;
+    length?: number;
+    playbackPosition?: number;
+    requestId?: string;
+}
+export interface ConsoleResponse extends AutomationResponse {
+    output?: string;
+    command?: string;
+}
+//# sourceMappingURL=automation-responses.d.ts.map

package/dist/types/automation-responses.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=automation-responses.js.map

package/dist/types/env.d.ts

@@ -1,7 +1,4 @@
 export interface Env {
-    UE_HOST: string;
-    UE_RC_WS_PORT: number;
-    UE_RC_HTTP_PORT: number;
     UE_PROJECT_PATH?: string;
     UE_EDITOR_EXE?: string;
     UE_SCREENSHOT_DIR?: string;

package/dist/types/env.js

@@ -1,15 +1,8 @@
 export function loadEnv() {
-    const host = process.env.UE_HOST || '127.0.0.1';
-    // Note: UE5 default is HTTP on 30010, WebSocket on 30020
-    const wsPort = Number(process.env.UE_RC_WS_PORT || process.env.UE_REMOTE_CONTROL_WS_PORT || 30020);
-    const httpPort = Number(process.env.UE_RC_HTTP_PORT || process.env.UE_REMOTE_CONTROL_HTTP_PORT || 30010);
     const projectPath = process.env.UE_PROJECT_PATH;
     const editorExe = process.env.UE_EDITOR_EXE;
     const screenshotDir = process.env.UE_SCREENSHOT_DIR;
     return {
-        UE_HOST: host,
-        UE_RC_WS_PORT: wsPort,
-        UE_RC_HTTP_PORT: httpPort,
         UE_PROJECT_PATH: projectPath,
         UE_EDITOR_EXE: editorExe,
         UE_SCREENSHOT_DIR: screenshotDir,