unreal-engine-mcp-server 0.4.6 → 0.5.0

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

@@ -0,0 +1,171 @@
+import { cleanObject } from '../../utils/safe-json.js';
+import { executeAutomationRequest, requireNonEmptyString } from './common-handlers.js';
+function ensureActionAndSubAction(action, args) {
+    if (!args || typeof args !== 'object')
+        return;
+    if (!args.action) {
+        args.action = action;
+    }
+    if (!args.subAction) {
+        args.subAction = args.action;
+    }
+}
+function isNonEmptyString(val) {
+    return typeof val === 'string' && val.trim().length > 0;
+}
+export async function handleEffectTools(action, args, tools) {
+    if (!args || typeof args !== 'object') {
+        args = {};
+    }
+    ensureActionAndSubAction(action, args);
+    if (action === 'create_niagara_system') {
+        const res = await tools.niagaraTools.createSystem({
+            name: args.name,
+            savePath: args.savePath,
+            template: args.template
+        });
+        return cleanObject(res);
+    }
+    if (action === 'create_niagara_emitter') {
+        const res = await tools.niagaraTools.createEmitter({
+            name: args.name,
+            savePath: args.savePath,
+            systemPath: args.systemPath,
+            template: args.template
+        });
+        return cleanObject(res);
+    }
+    if (args.action === 'particle') {
+        const presets = {
+            'Default': '/StarterContent/Particles/P_Steam_Lit.P_Steam_Lit',
+            'Smoke': '/StarterContent/Particles/P_Smoke.P_Smoke',
+            'Fire': '/StarterContent/Particles/P_Fire.P_Fire',
+            'Explosion': '/StarterContent/Particles/P_Explosion.P_Explosion',
+        };
+        const key = args.preset || args.effectType;
+        if (key && presets[key]) {
+            args.preset = presets[key];
+        }
+    }
+    if (action === 'debug_shape' || args.action === 'debug_shape') {
+        if (args.shape && !args.shapeType) {
+            args.shapeType = args.shape;
+        }
+        requireNonEmptyString(args.shapeType, 'shapeType', 'Missing required parameter: shapeType');
+        args.action = 'debug_shape';
+        args.subAction = 'debug_shape';
+        return cleanObject(await executeAutomationRequest(tools, 'create_effect', args));
+    }
+    const subAction = String(args.subAction || '').trim();
+    if (subAction === 'niagara' || subAction === 'spawn_niagara') {
+        requireNonEmptyString(args.systemPath, 'systemPath', 'Missing required parameter: systemPath');
+    }
+    if (subAction === 'activate_niagara' || subAction === 'deactivate_niagara' || subAction === 'advance_simulation') {
+        const systemName = args.systemName ?? args.actorName;
+        requireNonEmptyString(systemName, 'systemName', 'Missing required parameter: systemName (or actorName)');
+        args.systemName = systemName;
+    }
+    if (subAction === 'set_niagara_parameter') {
+        const systemName = args.systemName ?? args.actorName;
+        requireNonEmptyString(systemName, 'systemName', 'Missing required parameter: systemName (or actorName)');
+        requireNonEmptyString(args.parameterName, 'parameterName', 'Missing required parameter: parameterName');
+        if (!isNonEmptyString(args.parameterType) && isNonEmptyString(args.type)) {
+            args.parameterType = args.type.charAt(0).toUpperCase() + args.type.slice(1);
+        }
+        requireNonEmptyString(args.parameterType, 'parameterType', 'Missing required parameter: parameterType');
+        args.systemName = systemName;
+    }
+    if (action === 'clear_debug_shapes') {
+        return executeAutomationRequest(tools, action, args);
+    }
+    if (action === 'cleanup') {
+        args.action = 'cleanup';
+        args.subAction = 'cleanup';
+        return executeAutomationRequest(tools, 'create_effect', args);
+    }
+    const createActions = [
+        'create_volumetric_fog',
+        'create_particle_trail',
+        'create_environment_effect',
+        'create_impact_effect',
+        'create_niagara_ribbon'
+    ];
+    if (createActions.includes(action)) {
+        args.action = action;
+        return executeAutomationRequest(tools, 'create_effect', args);
+    }
+    if (action === 'activate' || action === 'activate_effect') {
+        args.action = 'activate_niagara';
+        args.systemName = args.actorName || args.systemName;
+        requireNonEmptyString(args.systemName, 'systemName', 'Missing required parameter: systemName (or actorName)');
+        args.reset = true;
+        return executeAutomationRequest(tools, 'create_effect', args);
+    }
+    if (action === 'deactivate') {
+        args.action = 'deactivate_niagara';
+        args.systemName = args.actorName || args.systemName;
+        requireNonEmptyString(args.systemName, 'systemName', 'Missing required parameter: systemName (or actorName)');
+        return executeAutomationRequest(tools, 'create_effect', args);
+    }
+    if (action === 'reset') {
+        args.action = 'activate_niagara';
+        args.systemName = args.actorName || args.systemName;
+        requireNonEmptyString(args.systemName, 'systemName', 'Missing required parameter: systemName (or actorName)');
+        args.reset = true;
+        return executeAutomationRequest(tools, 'create_effect', args);
+    }
+    if (action === 'advance_simulation') {
+        args.action = 'advance_simulation';
+        args.systemName = args.actorName || args.systemName;
+        requireNonEmptyString(args.systemName, 'systemName', 'Missing required parameter: systemName (or actorName)');
+        return executeAutomationRequest(tools, 'create_effect', args);
+    }
+    if (action === 'set_niagara_parameter') {
+        args.action = 'set_niagara_parameter';
+        if (args.actorName && !args.systemName) {
+            args.systemName = args.actorName;
+        }
+        if (args.type && !args.parameterType) {
+            args.parameterType = args.type.charAt(0).toUpperCase() + args.type.slice(1);
+        }
+        requireNonEmptyString(args.systemName, 'systemName', 'Missing required parameter: systemName (or actorName)');
+        requireNonEmptyString(args.parameterName, 'parameterName', 'Missing required parameter: parameterName');
+        requireNonEmptyString(args.parameterType, 'parameterType', 'Missing required parameter: parameterType');
+        return executeAutomationRequest(tools, 'create_effect', args);
+    }
+    const res = await executeAutomationRequest(tools, 'create_effect', args, 'Automation bridge not available for effect creation operations');
+    const result = res?.result ?? res ?? {};
+    const topError = typeof res?.error === 'string' ? res.error : '';
+    const nestedError = typeof result.error === 'string' ? result.error : '';
+    const errorCode = (topError || nestedError).toUpperCase();
+    const topMessage = typeof res?.message === 'string' ? res.message : '';
+    const nestedMessage = typeof result.message === 'string' ? result.message : '';
+    const message = topMessage || nestedMessage || '';
+    const combined = `${topError} ${nestedError} ${message}`.toLowerCase();
+    if (action === 'niagara' &&
+        (errorCode === 'SYSTEM_NOT_FOUND' ||
+            combined.includes('niagara system not found') ||
+            combined.includes('system asset not found'))) {
+        return cleanObject({
+            success: false,
+            error: 'SYSTEM_NOT_FOUND',
+            message: message || 'Niagara system not found',
+            systemPath: args.systemPath,
+            handled: true
+        });
+    }
+    if (action === 'spawn_niagara' && errorCode === 'SYSTEM_NOT_FOUND' && args.systemPath) {
+        const path = args.systemPath;
+        const name = path.split('/').pop();
+        if (name && !path.endsWith(`.${name}`)) {
+            return cleanObject({
+                success: false,
+                error: 'SYSTEM_NOT_FOUND',
+                message: `Niagara System not found at ${path}. Did you mean ${path}.${name}?`,
+                systemPath: path
+            });
+        }
+    }
+    return cleanObject(res);
+}
+//# sourceMappingURL=effect-handlers.js.map

package/dist/tools/handlers/environment-handlers.d.ts

@@ -0,0 +1,3 @@
+import { ITools } from '../../types/tool-interfaces.js';
+export declare function handleEnvironmentTools(action: string, args: any, tools: ITools): Promise<any>;
+//# sourceMappingURL=environment-handlers.d.ts.map

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

@@ -0,0 +1,170 @@
+import { cleanObject } from '../../utils/safe-json.js';
+import { executeAutomationRequest } from './common-handlers.js';
+export async function handleEnvironmentTools(action, args, tools) {
+    const envAction = String(action || '').toLowerCase();
+    switch (envAction) {
+        case 'create_landscape':
+            return cleanObject(await tools.landscapeTools.createLandscape({
+                name: args.name,
+                location: args.location,
+                sizeX: args.sizeX,
+                sizeY: args.sizeY,
+                quadsPerSection: args.quadsPerSection,
+                sectionsPerComponent: args.sectionsPerComponent,
+                componentCount: args.componentCount,
+                materialPath: args.materialPath,
+                enableWorldPartition: args.enableWorldPartition,
+                runtimeGrid: args.runtimeGrid,
+                isSpatiallyLoaded: args.isSpatiallyLoaded,
+                dataLayers: args.dataLayers
+            }));
+        case 'modify_heightmap':
+            return cleanObject(await tools.landscapeTools.modifyHeightmap({
+                landscapeName: args.landscapeName || args.name,
+                heightData: args.heightData,
+                minX: args.minX,
+                minY: args.minY,
+                maxX: args.maxX,
+                maxY: args.maxY,
+                updateNormals: args.updateNormals
+            }));
+        case 'sculpt':
+        case 'sculpt_landscape': {
+            const tool = args.tool || 'Raise';
+            return cleanObject(await tools.landscapeTools.sculptLandscape({
+                landscapeName: args.landscapeName || args.name,
+                tool,
+                location: args.location,
+                radius: args.radius || 500,
+                strength: args.strength || 0.5
+            }));
+        }
+        case 'add_foliage': {
+            if (args.meshPath) {
+                const defaultName = args.meshPath.split('/').pop()?.split('.')[0] + '_Foliage_Type';
+                return cleanObject(await tools.foliageTools.addFoliageType({
+                    name: args.foliageType || args.name || defaultName,
+                    meshPath: args.meshPath,
+                    density: args.density
+                }));
+            }
+            else {
+                const foliageType = args.foliageType || args.foliageTypePath;
+                if (!foliageType) {
+                    return cleanObject({
+                        success: false,
+                        error: 'INVALID_ARGUMENT',
+                        message: 'add_foliage requires either: (1) meshPath to create a new foliage type, or (2) foliageType/foliageTypePath to place instances of an existing type. Example foliage assets: /Game/StarterContent/Props/SM_Bush, /Engine/BasicShapes/Sphere'
+                    });
+                }
+                let locations = args.locations;
+                if (!locations && args.location && args.radius) {
+                    const center = args.location;
+                    const radius = args.radius || 500;
+                    const count = args.density || args.count || 10;
+                    locations = [];
+                    for (let i = 0; i < count; i++) {
+                        const angle = Math.random() * Math.PI * 2;
+                        const dist = Math.random() * radius;
+                        locations.push({
+                            x: (center.x || 0) + Math.cos(angle) * dist,
+                            y: (center.y || 0) + Math.sin(angle) * dist,
+                            z: center.z || 0
+                        });
+                    }
+                }
+                else if (!locations && args.position) {
+                    locations = [args.position];
+                }
+                if (!locations || locations.length === 0) {
+                    return cleanObject({
+                        success: false,
+                        error: 'INVALID_ARGUMENT',
+                        message: 'add_foliage requires locations to place foliage instances. Provide: locations array, or location+radius, or position'
+                    });
+                }
+                return cleanObject(await tools.foliageTools.addFoliage({
+                    foliageType,
+                    locations
+                }));
+            }
+        }
+        case 'add_foliage_instances':
+            return cleanObject(await tools.foliageTools.addFoliageInstances({
+                foliageType: args.foliageType || args.foliageTypePath || args.meshPath,
+                transforms: args.transforms || (args.locations ? args.locations.map((l) => ({ location: [l.x, l.y, l.z] })) : [])
+            }));
+        case 'paint_foliage':
+            return cleanObject(await tools.foliageTools.paintFoliage({
+                foliageType: args.foliageType || args.foliageTypePath,
+                position: args.position || args.location,
+                brushSize: args.brushSize || args.radius,
+                paintDensity: args.density || args.strength,
+                eraseMode: args.eraseMode
+            }));
+        case 'create_procedural_terrain':
+            return cleanObject(await tools.landscapeTools.createProceduralTerrain({
+                name: args.name,
+                location: args.location,
+                subdivisions: args.subdivisions,
+                settings: args.settings
+            }));
+        case 'create_procedural_foliage':
+            return cleanObject(await tools.foliageTools.createProceduralFoliage({
+                name: args.name,
+                foliageTypes: args.foliageTypes,
+                volumeName: args.volumeName,
+                bounds: args.bounds,
+                seed: args.seed,
+                tileSize: args.tileSize
+            }));
+        case 'bake_lightmap':
+            return cleanObject(await tools.lightingTools.buildLighting({
+                quality: args.quality || 'Preview',
+                buildOnlySelected: false,
+                buildReflectionCaptures: false
+            }));
+        case 'create_landscape_grass_type':
+            return cleanObject(await tools.landscapeTools.createLandscapeGrassType({
+                name: args.name,
+                meshPath: args.meshPath || args.path || args.staticMesh,
+                path: args.path,
+                staticMesh: args.staticMesh
+            }));
+        case 'export_snapshot':
+            return cleanObject(await tools.environmentTools.exportSnapshot({
+                path: args.path,
+                filename: args.filename
+            }));
+        case 'import_snapshot':
+            return cleanObject(await tools.environmentTools.importSnapshot({
+                path: args.path,
+                filename: args.filename
+            }));
+        case 'set_landscape_material':
+            return cleanObject(await tools.landscapeTools.setLandscapeMaterial({
+                landscapeName: args.landscapeName || args.name,
+                materialPath: args.materialPath
+            }));
+        case 'generate_lods':
+            return cleanObject(await executeAutomationRequest(tools, 'build_environment', {
+                action: 'generate_lods',
+                assetPaths: args.assetPaths || args.assets || (args.path ? [args.path] : []),
+                numLODs: args.numLODs
+            }, 'Bridge unavailable'));
+        case 'delete': {
+            const names = Array.isArray(args.names)
+                ? args.names
+                : (Array.isArray(args.actors) ? args.actors : []);
+            if (args.name) {
+                names.push(args.name);
+            }
+            const res = await tools.environmentTools.cleanup({ names });
+            return cleanObject(res);
+        }
+        default:
+            const res = await executeAutomationRequest(tools, 'build_environment', args, 'Automation bridge not available for environment building operations');
+            return cleanObject(res);
+    }
+}
+//# sourceMappingURL=environment-handlers.js.map

package/dist/tools/handlers/graph-handlers.d.ts

@@ -0,0 +1,3 @@
+import { ITools } from '../../types/tool-interfaces.js';
+export declare function handleGraphTools(toolName: string, action: string, args: any, tools: ITools): Promise<any>;
+//# sourceMappingURL=graph-handlers.d.ts.map

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

@@ -0,0 +1,90 @@
+import { cleanObject } from '../../utils/safe-json.js';
+import { executeAutomationRequest } from './common-handlers.js';
+export async function handleGraphTools(toolName, action, args, tools) {
+    if (!args.assetPath && !args.blueprintPath && !args.systemPath) {
+    }
+    switch (toolName) {
+        case 'manage_blueprint_graph':
+            return handleBlueprintGraph(action, args, tools);
+        case 'manage_niagara_graph':
+            return handleNiagaraGraph(action, args, tools);
+        case 'manage_material_graph':
+            return handleMaterialGraph(action, args, tools);
+        case 'manage_behavior_tree':
+            return handleBehaviorTree(action, args, tools);
+        default:
+            return { success: false, error: 'UNKNOWN_TOOL', message: `Unknown graph tool: ${toolName}` };
+    }
+}
+async function handleBlueprintGraph(action, args, tools) {
+    const processedArgs = { ...args, subAction: action };
+    if (!processedArgs.graphName) {
+        processedArgs.graphName = 'EventGraph';
+    }
+    if (processedArgs.nodeType === 'FunctionCall') {
+        processedArgs.nodeType = 'CallFunction';
+    }
+    if (processedArgs.memberName) {
+        if (processedArgs.nodeType === 'VariableGet' || processedArgs.nodeType === 'VariableSet') {
+            if (!processedArgs.variableName)
+                processedArgs.variableName = processedArgs.memberName;
+        }
+        else if (processedArgs.nodeType === 'Event' || processedArgs.nodeType === 'CustomEvent' || (processedArgs.nodeType && processedArgs.nodeType.startsWith('K2Node_Event'))) {
+            if (!processedArgs.eventName)
+                processedArgs.eventName = processedArgs.memberName;
+        }
+        else if (processedArgs.nodeType === 'CallFunction' || processedArgs.nodeType === 'K2Node_CallFunction') {
+        }
+    }
+    if ((processedArgs.memberClass || processedArgs.componentClass) &&
+        (processedArgs.nodeType === 'Cast' || (processedArgs.nodeType && processedArgs.nodeType.startsWith('CastTo')))) {
+        if (!processedArgs.targetClass)
+            processedArgs.targetClass = processedArgs.memberClass || processedArgs.componentClass;
+    }
+    if (action === 'connect_pins') {
+        if (!processedArgs.fromNodeId && processedArgs.nodeId) {
+            processedArgs.fromNodeId = processedArgs.nodeId;
+        }
+        if (!processedArgs.fromPinName && processedArgs.pinName) {
+            processedArgs.fromPinName = processedArgs.pinName;
+        }
+        if (!processedArgs.toNodeId && processedArgs.linkedTo) {
+            if (processedArgs.linkedTo.includes('.')) {
+                const parts = processedArgs.linkedTo.split('.');
+                processedArgs.toNodeId = parts[0];
+                processedArgs.toPinName = parts.slice(1).join('.');
+            }
+        }
+    }
+    if (action === 'connect_pins') {
+        if (processedArgs.fromNodeId && processedArgs.fromNodeId.includes('.') && !processedArgs.fromPinName) {
+            const parts = processedArgs.fromNodeId.split('.');
+            processedArgs.fromNodeId = parts[0];
+            processedArgs.fromPinName = parts.slice(1).join('.');
+        }
+        if (processedArgs.toNodeId && processedArgs.toNodeId.includes('.') && !processedArgs.toPinName) {
+            const parts = processedArgs.toNodeId.split('.');
+            processedArgs.toNodeId = parts[0];
+            processedArgs.toPinName = parts.slice(1).join('.');
+        }
+    }
+    const res = await executeAutomationRequest(tools, 'manage_blueprint_graph', processedArgs, 'Automation bridge not available');
+    return cleanObject({ ...res, ...(res.result || {}) });
+}
+async function handleNiagaraGraph(action, args, tools) {
+    const payload = { ...args, subAction: action };
+    if (payload.systemPath && !payload.assetPath) {
+        payload.assetPath = payload.systemPath;
+    }
+    const res = await executeAutomationRequest(tools, 'manage_niagara_graph', payload, 'Automation bridge not available');
+    return cleanObject({ ...res, ...(res.result || {}) });
+}
+async function handleMaterialGraph(action, args, tools) {
+    const res = await executeAutomationRequest(tools, 'manage_material_graph', { ...args, subAction: action }, 'Automation bridge not available');
+    return cleanObject({ ...res, ...(res.result || {}) });
+}
+async function handleBehaviorTree(action, args, tools) {
+    const res = await executeAutomationRequest(tools, 'manage_behavior_tree', { ...args, subAction: action }, 'Automation bridge not available');
+    return cleanObject({ ...res, ...(res.result || {}) });
+}
+//# sourceMappingURL=graph-handlers.js.map

package/dist/tools/handlers/input-handlers.d.ts

@@ -0,0 +1,3 @@
+import { ITools } from '../../types/tool-interfaces.js';
+export declare function handleInputTools(action: string, args: any, tools: ITools): Promise<any>;
+//# sourceMappingURL=input-handlers.d.ts.map

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

@@ -0,0 +1,21 @@
+import { cleanObject } from '../../utils/safe-json.js';
+import { ResponseFactory } from '../../utils/response-factory.js';
+export async function handleInputTools(action, args, tools) {
+    const inputTools = tools.inputTools;
+    if (!inputTools) {
+        return ResponseFactory.error('Input tools not available');
+    }
+    switch (action) {
+        case 'create_input_action':
+            return cleanObject(await inputTools.createInputAction(args.name, args.path));
+        case 'create_input_mapping_context':
+            return cleanObject(await inputTools.createInputMappingContext(args.name, args.path));
+        case 'add_mapping':
+            return cleanObject(await inputTools.addMapping(args.contextPath, args.actionPath, args.key));
+        case 'remove_mapping':
+            return cleanObject(await inputTools.removeMapping(args.contextPath, args.actionPath));
+        default:
+            return ResponseFactory.error(`Unknown input action: ${action}`);
+    }
+}
+//# sourceMappingURL=input-handlers.js.map

package/dist/tools/handlers/inspect-handlers.d.ts

@@ -0,0 +1,3 @@
+import { ITools } from '../../types/tool-interfaces.js';
+export declare function handleInspectTools(action: string, args: any, tools: ITools): Promise<any>;
+//# sourceMappingURL=inspect-handlers.d.ts.map