unreal-engine-mcp-server 0.4.7 → 0.5.0

package/dist/tools/handlers/system-handlers.js

@@ -0,0 +1,506 @@
+import { cleanObject } from '../../utils/safe-json.js';
+import { executeAutomationRequest } from './common-handlers.js';
+export async function handleSystemTools(action, args, tools) {
+    const sysAction = String(action || '').toLowerCase();
+    switch (sysAction) {
+        case 'show_fps':
+            await tools.systemTools.executeConsoleCommand(args.enabled !== false ? 'stat fps' : 'stat fps 0');
+            return { success: true, message: `FPS display ${args.enabled !== false ? 'enabled' : 'disabled'}`, action: 'show_fps' };
+        case 'profile': {
+            const rawType = typeof args?.profileType === 'string' ? args.profileType.trim() : '';
+            const profileKey = rawType ? rawType.toLowerCase() : 'cpu';
+            const enabled = args?.enabled !== false;
+            const profileMap = {
+                cpu: 'stat unit',
+                gamethread: 'stat game',
+                renderthread: 'stat scenerendering',
+                gpu: 'stat gpu',
+                memory: 'stat memory',
+                fps: 'stat fps',
+                all: 'stat unit'
+            };
+            const cmd = profileMap[profileKey];
+            if (!cmd) {
+                return {
+                    success: false,
+                    error: 'INVALID_PROFILE_TYPE',
+                    message: `Unsupported profileType: ${rawType || String(args?.profileType ?? '')}`,
+                    action: 'profile',
+                    profileType: args?.profileType
+                };
+            }
+            await tools.systemTools.executeConsoleCommand(cmd);
+            return {
+                success: true,
+                message: `Profiling ${enabled ? 'enabled' : 'disabled'} (${rawType || 'CPU'})`,
+                action: 'profile',
+                profileType: rawType || 'CPU'
+            };
+        }
+        case 'set_quality':
+            const quality = args.quality || args.level || 'medium';
+            let qVal;
+            if (typeof quality === 'number') {
+                qVal = quality;
+            }
+            else {
+                const qStr = String(quality).toLowerCase();
+                qVal = (qStr === 'high' || qStr === 'epic') ? 3 : (qStr === 'low' ? 0 : (qStr === 'cinematic' ? 4 : 1));
+            }
+            const category = String(args.category || 'ViewDistance').toLowerCase();
+            let cvar = 'sg.ViewDistanceQuality';
+            if (category.includes('shadow'))
+                cvar = 'sg.ShadowQuality';
+            else if (category.includes('texture'))
+                cvar = 'sg.TextureQuality';
+            else if (category.includes('effect'))
+                cvar = 'sg.EffectsQuality';
+            else if (category.includes('postprocess'))
+                cvar = 'sg.PostProcessQuality';
+            else if (category.includes('foliage'))
+                cvar = 'sg.FoliageQuality';
+            else if (category.includes('shading'))
+                cvar = 'sg.ShadingQuality';
+            else if (category.includes('globalillumination') || category.includes('gi'))
+                cvar = 'sg.GlobalIlluminationQuality';
+            else if (category.includes('reflection'))
+                cvar = 'sg.ReflectionQuality';
+            else if (category.includes('viewdistance'))
+                cvar = 'sg.ViewDistanceQuality';
+            await tools.systemTools.executeConsoleCommand(`${cvar} ${qVal}`);
+            return { success: true, message: `${category} quality derived from '${quality}' set to ${qVal} via ${cvar}`, action: 'set_quality' };
+        case 'execute_command':
+            return cleanObject(await tools.systemTools.executeConsoleCommand(args.command));
+        case 'create_widget': {
+            const name = typeof args?.name === 'string' ? args.name.trim() : '';
+            const widgetPathRaw = typeof args?.widgetPath === 'string' ? args.widgetPath.trim() : '';
+            let effectiveName = name || `NewWidget_${Date.now()}`;
+            let effectivePath = typeof args?.savePath === 'string' ? args.savePath.trim() : '';
+            if (!name && widgetPathRaw) {
+                const parts = widgetPathRaw.split('/').filter((p) => p.length > 0);
+                if (parts.length > 0) {
+                    effectiveName = parts[parts.length - 1];
+                    if (!effectivePath) {
+                        effectivePath = '/' + parts.slice(0, parts.length - 1).join('/');
+                    }
+                }
+            }
+            if (!effectiveName) {
+                return {
+                    success: false,
+                    error: 'INVALID_ARGUMENT',
+                    message: 'Widget name is required for creation',
+                    action: 'create_widget'
+                };
+            }
+            try {
+                const res = await tools.uiTools.createWidget({
+                    name: effectiveName,
+                    type: args?.widgetType,
+                    savePath: effectivePath
+                });
+                return cleanObject({
+                    ...res,
+                    action: 'create_widget'
+                });
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                return {
+                    success: false,
+                    error: `Failed to create widget: ${msg}`,
+                    message: msg,
+                    action: 'create_widget'
+                };
+            }
+        }
+        case 'show_widget': {
+            const widgetId = typeof args?.widgetId === 'string' ? args.widgetId.trim() : '';
+            if (widgetId.toLowerCase() === 'notification') {
+                const text = typeof args?.message === 'string' && args.message.trim().length > 0
+                    ? args.message
+                    : 'Notification';
+                const duration = typeof args?.duration === 'number' ? args.duration : undefined;
+                try {
+                    const res = await tools.uiTools.showNotification({ text, duration });
+                    const ok = res && res.success !== false;
+                    if (ok) {
+                        return {
+                            success: true,
+                            message: res.message || 'Notification shown',
+                            action: 'show_widget',
+                            widgetId,
+                            handled: true
+                        };
+                    }
+                    return cleanObject({
+                        success: false,
+                        error: res?.error || 'NOTIFICATION_FAILED',
+                        message: res?.message || 'Failed to show notification',
+                        action: 'show_widget',
+                        widgetId
+                    });
+                }
+                catch (error) {
+                    const msg = error instanceof Error ? error.message : String(error);
+                    return {
+                        success: false,
+                        error: 'NOTIFICATION_FAILED',
+                        message: msg,
+                        action: 'show_widget',
+                        widgetId
+                    };
+                }
+            }
+            const widgetPath = (typeof args?.widgetPath === 'string' ? args.widgetPath.trim() : '') || (typeof args?.name === 'string' ? args.name.trim() : '');
+            if (!widgetPath) {
+                return {
+                    success: false,
+                    error: 'INVALID_ARGUMENT',
+                    message: 'widgetPath (or name) is required to show a widget',
+                    action: 'show_widget',
+                    widgetId
+                };
+            }
+            return cleanObject(await tools.uiTools.showWidget(widgetPath));
+        }
+        case 'add_widget_child': {
+            const widgetPath = typeof args?.widgetPath === 'string' ? args.widgetPath.trim() : '';
+            const childClass = typeof args?.childClass === 'string' ? args.childClass.trim() : '';
+            const parentName = typeof args?.parentName === 'string' ? args.parentName.trim() : undefined;
+            if (!widgetPath || !childClass) {
+                return {
+                    success: false,
+                    error: 'INVALID_ARGUMENT',
+                    message: 'widgetPath and childClass are required',
+                    action: 'add_widget_child'
+                };
+            }
+            try {
+                const res = await tools.uiTools.addWidgetComponent({
+                    widgetName: widgetPath,
+                    componentType: childClass,
+                    componentName: 'NewChild',
+                    slot: parentName ? { position: [0, 0] } : undefined
+                });
+                return cleanObject({
+                    ...res,
+                    action: 'add_widget_child'
+                });
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                return {
+                    success: false,
+                    error: `Failed to add widget child: ${msg}`,
+                    message: msg,
+                    action: 'add_widget_child'
+                };
+            }
+        }
+        case 'set_cvar': {
+            const rawInput = typeof args?.name === 'string' && args.name.trim().length > 0
+                ? args.name.trim()
+                : (typeof args?.cvar === 'string' ? args.cvar.trim()
+                    : (typeof args?.key === 'string' ? args.key.trim()
+                        : (typeof args?.command === 'string' ? args.command.trim() : '')));
+            const tokens = rawInput.split(/\s+/).filter(Boolean);
+            const rawName = tokens[0] ?? '';
+            if (!rawName) {
+                return {
+                    success: false,
+                    error: 'INVALID_ARGUMENT',
+                    message: 'CVar name is required',
+                    action: 'set_cvar'
+                };
+            }
+            const value = (args?.value !== undefined && args?.value !== null)
+                ? args.value
+                : (tokens.length > 1 ? tokens.slice(1).join(' ') : '');
+            await tools.systemTools.executeConsoleCommand(`${rawName} ${value}`);
+            return {
+                success: true,
+                message: `CVar ${rawName} set to ${value}`,
+                action: 'set_cvar',
+                cvar: rawName,
+                value
+            };
+        }
+        case 'get_project_settings': {
+            const section = typeof args?.category === 'string' && args.category.trim().length > 0
+                ? args.category
+                : args?.section;
+            const resp = await tools.systemTools.getProjectSettings(section);
+            if (resp && resp.success && (resp.settings || resp.data || resp.result)) {
+                return cleanObject({
+                    success: true,
+                    message: 'Project settings retrieved',
+                    settings: resp.settings || resp.data || resp.result,
+                    ...resp
+                });
+            }
+            return cleanObject(resp);
+        }
+        case 'validate_assets': {
+            const paths = Array.isArray(args?.paths) ? args.paths : [];
+            if (!paths.length) {
+                return {
+                    success: false,
+                    error: 'INVALID_ARGUMENT',
+                    message: 'Please provide array of "paths" to validate assets.',
+                    action: 'validate_assets',
+                    results: []
+                };
+            }
+            const results = [];
+            for (const rawPath of paths) {
+                const assetPath = typeof rawPath === 'string' ? rawPath : String(rawPath ?? '');
+                try {
+                    const res = await tools.assetTools.validate({ assetPath });
+                    results.push({ assetPath, ...res });
+                }
+                catch (error) {
+                    results.push({
+                        assetPath,
+                        success: false,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+            return {
+                success: true,
+                message: 'Asset validation completed',
+                action: 'validate_assets',
+                results
+            };
+        }
+        case 'play_sound': {
+            const soundPath = typeof args?.soundPath === 'string' ? args.soundPath.trim() : '';
+            const volume = typeof args?.volume === 'number' ? args.volume : undefined;
+            const pitch = typeof args?.pitch === 'number' ? args.pitch : undefined;
+            if (typeof volume === 'number' && volume <= 0) {
+                return {
+                    success: true,
+                    message: 'Sound request handled (volume is 0 - silent)',
+                    action: 'play_sound',
+                    soundPath,
+                    volume,
+                    pitch,
+                    handled: true
+                };
+            }
+            try {
+                const res = await tools.audioTools.playSound(soundPath, volume, pitch);
+                if (!res || res.success === false) {
+                    const errText = String(res?.error || '').toLowerCase();
+                    const isMissingAsset = errText.includes('asset_not_found') || errText.includes('asset not found');
+                    if (isMissingAsset || !soundPath) {
+                        const fallbackPath = '/Engine/EditorSounds/Notifications/CompileSuccess_Cue';
+                        if (soundPath !== fallbackPath) {
+                            const fallbackRes = await tools.audioTools.playSound(fallbackPath, volume, pitch);
+                            if (fallbackRes.success) {
+                                return {
+                                    success: true,
+                                    message: `Sound asset not found, played fallback sound: ${fallbackPath}`,
+                                    action: 'play_sound',
+                                    soundPath: fallbackPath,
+                                    originalPath: soundPath,
+                                    volume,
+                                    pitch
+                                };
+                            }
+                        }
+                        return {
+                            success: false,
+                            error: 'ASSET_NOT_FOUND',
+                            message: 'Sound asset not found (and fallback failed)',
+                            action: 'play_sound',
+                            soundPath,
+                            volume,
+                            pitch
+                        };
+                    }
+                    return cleanObject({
+                        success: false,
+                        error: res?.error || 'Failed to play 2D sound',
+                        action: 'play_sound',
+                        soundPath,
+                        volume,
+                        pitch
+                    });
+                }
+                return cleanObject({
+                    ...res,
+                    action: 'play_sound',
+                    soundPath,
+                    volume,
+                    pitch
+                });
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                const lowered = msg.toLowerCase();
+                const isMissingAsset = lowered.includes('asset_not_found') || lowered.includes('asset not found');
+                if (isMissingAsset || !soundPath) {
+                    return {
+                        success: false,
+                        error: 'ASSET_NOT_FOUND',
+                        message: 'Sound asset not found',
+                        action: 'play_sound',
+                        soundPath,
+                        volume,
+                        pitch
+                    };
+                }
+                if (isMissingAsset) {
+                    const fallbackSound = '/Engine/EditorSounds/Notifications/CompileSuccess_Cue';
+                    try {
+                        const fallbackRes = await tools.audioTools.playSound(fallbackSound, volume, pitch);
+                        if (fallbackRes && fallbackRes.success) {
+                            return {
+                                success: true,
+                                message: `Original sound not found. Played fallback sound: ${fallbackSound}`,
+                                action: 'play_sound',
+                                soundPath,
+                                fallback: true,
+                                volume,
+                                pitch
+                            };
+                        }
+                    }
+                    catch (_fallbackErr) {
+                    }
+                }
+                return {
+                    success: false,
+                    error: `Failed to play 2D sound: ${msg}`,
+                    action: 'play_sound',
+                    soundPath,
+                    volume,
+                    pitch
+                };
+            }
+        }
+        case 'screenshot': {
+            const includeMetadata = args?.includeMetadata === true;
+            const filenameArg = typeof args?.filename === 'string' ? args.filename : undefined;
+            if (includeMetadata) {
+                const baseName = filenameArg && filenameArg.trim().length > 0
+                    ? filenameArg.trim()
+                    : `Screenshot_${Date.now()}`;
+                try {
+                    await tools.editorTools.takeScreenshot(baseName);
+                }
+                catch (error) {
+                    const msg = error instanceof Error ? error.message : String(error);
+                    return {
+                        success: false,
+                        error: 'SCREENSHOT_FAILED',
+                        message: msg,
+                        filename: baseName,
+                        includeMetadata: true,
+                        metadata: args?.metadata,
+                        action: 'screenshot'
+                    };
+                }
+                return {
+                    success: true,
+                    message: `Metadata screenshot captured: ${baseName}`,
+                    filename: baseName,
+                    includeMetadata: true,
+                    metadata: args?.metadata,
+                    action: 'screenshot',
+                    handled: true
+                };
+            }
+            return cleanObject(await tools.editorTools.takeScreenshot(filenameArg));
+        }
+        case 'set_resolution': {
+            const parseResolution = (value) => {
+                if (typeof value !== 'string')
+                    return {};
+                const m = value.trim().match(/^(\d+)x(\d+)$/i);
+                if (!m)
+                    return {};
+                return { width: Number(m[1]), height: Number(m[2]) };
+            };
+            const parsed = parseResolution(args?.resolution);
+            const width = Number.isFinite(Number(args.width)) ? Number(args.width) : (parsed.width ?? NaN);
+            const height = Number.isFinite(Number(args.height)) ? Number(args.height) : (parsed.height ?? NaN);
+            if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+                return {
+                    success: false,
+                    error: 'VALIDATION_ERROR',
+                    message: 'Validation error: Invalid resolution: width and height must be positive numbers',
+                    action: 'set_resolution'
+                };
+            }
+            const windowed = args.windowed !== false;
+            const suffix = windowed ? 'w' : 'f';
+            await tools.systemTools.executeConsoleCommand(`r.SetRes ${width}x${height}${suffix}`);
+            return {
+                success: true,
+                message: `Resolution set to ${width}x${height} (${windowed ? 'windowed' : 'fullscreen'})`,
+                action: 'set_resolution'
+            };
+        }
+        case 'set_fullscreen': {
+            const parseResolution = (value) => {
+                if (typeof value !== 'string')
+                    return {};
+                const m = value.trim().match(/^(\d+)x(\d+)$/i);
+                if (!m)
+                    return {};
+                return { width: Number(m[1]), height: Number(m[2]) };
+            };
+            const parsed = parseResolution(args?.resolution);
+            const width = Number.isFinite(Number(args.width)) ? Number(args.width) : (parsed.width ?? NaN);
+            const height = Number.isFinite(Number(args.height)) ? Number(args.height) : (parsed.height ?? NaN);
+            const windowed = args.windowed === true || args.enabled === false;
+            const suffix = windowed ? 'w' : 'f';
+            if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+                if (typeof args?.windowed === 'boolean' || typeof args?.enabled === 'boolean') {
+                    await tools.systemTools.executeConsoleCommand(`r.FullScreenMode ${windowed ? 1 : 0}`);
+                    return {
+                        success: true,
+                        message: `Fullscreen mode toggled (${windowed ? 'windowed' : 'fullscreen'})`,
+                        action: 'set_fullscreen',
+                        handled: true
+                    };
+                }
+                return {
+                    success: false,
+                    error: 'VALIDATION_ERROR',
+                    message: 'Invalid resolution: provide width/height or resolution like "1920x1080"',
+                    action: 'set_fullscreen'
+                };
+            }
+            await tools.systemTools.executeConsoleCommand(`r.SetRes ${width}x${height}${suffix}`);
+            return {
+                success: true,
+                message: `Fullscreen mode set to ${width}x${height} (${windowed ? 'windowed' : 'fullscreen'})`,
+                action: 'set_fullscreen'
+            };
+        }
+        case 'read_log':
+            return cleanObject(await tools.logTools.readOutputLog(args));
+        default:
+            const res = await executeAutomationRequest(tools, 'system_control', args, 'Automation bridge not available for system control operations');
+            return cleanObject(res);
+    }
+}
+export async function handleConsoleCommand(args, tools) {
+    const rawCommand = typeof args?.command === 'string' ? args.command : '';
+    const trimmed = rawCommand.trim();
+    if (!trimmed) {
+        return cleanObject({
+            success: false,
+            error: 'EMPTY_COMMAND',
+            message: 'Console command is empty',
+            command: rawCommand
+        });
+    }
+    const res = await executeAutomationRequest(tools, 'console_command', { ...args, command: trimmed }, 'Automation bridge not available for console command operations');
+    return cleanObject(res);
+}
+//# sourceMappingURL=system-handlers.js.map

package/dist/tools/input.d.ts

@@ -0,0 +1,19 @@
+import { AutomationBridge } from '../automation/index.js';
+interface ToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: object;
+    outputSchema: object;
+}
+export declare class InputTools {
+    private automationBridge;
+    constructor();
+    setAutomationBridge(bridge: AutomationBridge): void;
+    createInputAction(name: string, path: string): Promise<import("../automation/types.js").AutomationBridgeResponseMessage>;
+    createInputMappingContext(name: string, path: string): Promise<import("../automation/types.js").AutomationBridgeResponseMessage>;
+    addMapping(contextPath: string, actionPath: string, key: string): Promise<import("../automation/types.js").AutomationBridgeResponseMessage>;
+    removeMapping(contextPath: string, actionPath: string): Promise<import("../automation/types.js").AutomationBridgeResponseMessage>;
+}
+export declare const inputTools: ToolDefinition;
+export {};
+//# sourceMappingURL=input.d.ts.map

package/dist/tools/input.js

@@ -0,0 +1,89 @@
+export class InputTools {
+    automationBridge = null;
+    constructor() { }
+    setAutomationBridge(bridge) {
+        this.automationBridge = bridge;
+    }
+    async createInputAction(name, path) {
+        if (!this.automationBridge)
+            throw new Error('Automation bridge not set');
+        return this.automationBridge.sendAutomationRequest('manage_input', {
+            action: 'create_input_action',
+            name,
+            path
+        });
+    }
+    async createInputMappingContext(name, path) {
+        if (!this.automationBridge)
+            throw new Error('Automation bridge not set');
+        return this.automationBridge.sendAutomationRequest('manage_input', {
+            action: 'create_input_mapping_context',
+            name,
+            path
+        });
+    }
+    async addMapping(contextPath, actionPath, key) {
+        if (!this.automationBridge)
+            throw new Error('Automation bridge not set');
+        return this.automationBridge.sendAutomationRequest('manage_input', {
+            action: 'add_mapping',
+            contextPath,
+            actionPath,
+            key
+        });
+    }
+    async removeMapping(contextPath, actionPath) {
+        if (!this.automationBridge)
+            throw new Error('Automation bridge not set');
+        return this.automationBridge.sendAutomationRequest('manage_input', {
+            action: 'remove_mapping',
+            contextPath,
+            actionPath
+        });
+    }
+}
+export const inputTools = {
+    name: 'manage_input',
+    description: `Enhanced Input management.
+
+Use it when you need to:
+- create Input Actions (IA_*)
+- create Input Mapping Contexts (IMC_*)
+- bind keys to actions in a mapping context.
+
+Supported actions:
+- create_input_action: Create a UInputAction asset.
+- create_input_mapping_context: Create a UInputMappingContext asset.
+- add_mapping: Add a key mapping to a context.
+- remove_mapping: Remove a mapping from a context.`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: [
+                    'create_input_action',
+                    'create_input_mapping_context',
+                    'add_mapping',
+                    'remove_mapping'
+                ],
+                description: 'Action to perform'
+            },
+            name: { type: 'string', description: 'Name of the asset (for creation).' },
+            path: { type: 'string', description: 'Path to save the asset (e.g. /Game/Input).' },
+            contextPath: { type: 'string', description: 'Path to the Input Mapping Context.' },
+            actionPath: { type: 'string', description: 'Path to the Input Action.' },
+            key: { type: 'string', description: 'Key name (e.g. "SpaceBar", "W", "Gamepad_FaceButton_Bottom").' }
+        },
+        required: ['action']
+    },
+    outputSchema: {
+        type: 'object',
+        properties: {
+            success: { type: 'boolean' },
+            message: { type: 'string' },
+            assetPath: { type: 'string' }
+        }
+    }
+};
+//# sourceMappingURL=input.js.map