unreal-engine-mcp-server 0.5.0 → 0.5.2

package/dist/tools/level.js

@@ -1,4 +1,6 @@
 import { BaseTool } from './base-tool.js';
+import { sanitizePath } from '../utils/path-security.js';
+import { DEFAULT_OPERATION_TIMEOUT_MS, DEFAULT_ASSET_OP_TIMEOUT_MS, LONG_RUNNING_OP_TIMEOUT_MS } from '../constants.js';
 export class LevelTools extends BaseTool {
     managedLevels = new Map();
     listCache;
@@ -18,6 +20,12 @@ export class LevelTools extends BaseTool {
         if (!formatted.startsWith('/Game/')) {
             formatted = `/Game/${formatted.replace(/^\/+/, '')}`;
         }
+        try {
+            formatted = sanitizePath(formatted);
+        }
+        catch (e) {
+            throw new Error(`Security validation failed for level path: ${e instanceof Error ? e.message : String(e)}`);
+        }
         formatted = formatted.replace(/\.umap$/i, '');
         if (formatted.endsWith('/')) {
             formatted = formatted.slice(0, -1);
@@ -180,6 +188,7 @@ export class LevelTools extends BaseTool {
                 const managedOnly = managed.levels.filter(m => !ueLevels.some(u => u.path === m.path));
                 const finalLevels = [...ueLevels, ...managedOnly];
                 const result = {
+                    ...response,
                     success: true,
                     message: 'Levels listed from Unreal Engine',
                     levels: finalLevels,
@@ -190,7 +199,6 @@ export class LevelTools extends BaseTool {
                         levels: finalLevels,
                         count: finalLevels.length
                     },
-                    ...response,
                     managedLevels: managed.levels,
                     managedLevelCount: managed.count
                 };
@@ -234,7 +242,7 @@ export class LevelTools extends BaseTool {
                 action: 'export_level',
                 levelPath: resolved,
                 exportPath: params.exportPath
-            }, { timeoutMs: params.timeoutMs ?? 300000 });
+            }, { timeoutMs: params.timeoutMs ?? LONG_RUNNING_OP_TIMEOUT_MS });
             if (res?.success === false) {
                 return {
                     success: false,
@@ -253,7 +261,7 @@ export class LevelTools extends BaseTool {
             };
         }
         catch (e) {
-            return { success: false, error: `Export failed: ${e.message}` };
+            return { success: false, error: `Export failed: ${e instanceof Error ? e.message : String(e)}` };
         }
     }
     async importLevel(params) {
@@ -265,7 +273,7 @@ export class LevelTools extends BaseTool {
                 action: 'import_level',
                 packagePath: params.packagePath,
                 destinationPath: destination.path
-            }, { timeoutMs: params.timeoutMs ?? 300000 });
+            }, { timeoutMs: params.timeoutMs ?? LONG_RUNNING_OP_TIMEOUT_MS });
             if (res?.success === false) {
                 return {
                     success: false,
@@ -284,7 +292,7 @@ export class LevelTools extends BaseTool {
             };
         }
         catch (e) {
-            return { success: false, error: `Import failed: ${e.message}` };
+            return { success: false, error: `Import failed: ${e instanceof Error ? e.message : String(e)}` };
         }
     }
     async saveLevelAs(params) {
@@ -295,7 +303,7 @@ export class LevelTools extends BaseTool {
                 action: 'save_level_as',
                 savePath: target.path
             }, {
-                timeoutMs: 60000
+                timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS
             });
             if (response.success === false) {
                 return { success: false, error: response.error || response.message || 'Failed to save level as' };
@@ -382,7 +390,7 @@ export class LevelTools extends BaseTool {
                 const response = await this.sendAutomationRequest('manage_level', {
                     action: 'load',
                     levelPath: params.levelPath
-                }, { timeoutMs: 30000 });
+                }, { timeoutMs: DEFAULT_OPERATION_TIMEOUT_MS });
                 if (response.success) {
                     this.setCurrentLevel(normalizedPath);
                     this.mutateRecord(normalizedPath, {
@@ -391,11 +399,11 @@ export class LevelTools extends BaseTool {
                         visible: true
                     });
                     return {
+                        ...response,
                         success: true,
                         message: `Level loaded: ${params.levelPath}`,
                         level: normalizedPath,
-                        streaming: false,
-                        ...response
+                        streaming: false
                     };
                 }
             }
@@ -461,15 +469,15 @@ export class LevelTools extends BaseTool {
                 payload.savePath = params.savePath;
             }
             const response = await this.sendAutomationRequest('manage_level', payload, {
-                timeoutMs: 60000
+                timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS
             });
             if (response.success === false) {
                 return { success: false, error: response.error || response.message || 'Failed to save level' };
             }
             const result = {
+                ...response,
                 success: true,
-                message: response.message || 'Level saved',
-                ...response
+                message: response.message || 'Level saved'
             };
             if (response.skipped) {
                 result.skipped = response.skipped;
@@ -498,7 +506,7 @@ export class LevelTools extends BaseTool {
                 levelPath: fullPath,
                 useWorldPartition: isPartitioned
             }, {
-                timeoutMs: 60000
+                timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS
             });
             if (response.success === false) {
                 return {
@@ -509,13 +517,13 @@ export class LevelTools extends BaseTool {
                 };
             }
             const result = {
+                ...response,
                 success: true,
                 message: response.message || 'Level created',
                 path: response.levelPath || fullPath,
                 packagePath: response.packagePath ?? fullPath,
                 objectPath: response.objectPath,
-                partitioned: isPartitioned,
-                ...response
+                partitioned: isPartitioned
             };
             if (response.warnings) {
                 result.warnings = response.warnings;
@@ -551,7 +559,7 @@ export class LevelTools extends BaseTool {
                 subLevelPath: sub,
                 parentPath: parent,
                 streamingMethod: params.streamingMethod
-            }, { timeoutMs: 30000 });
+            }, { timeoutMs: DEFAULT_OPERATION_TIMEOUT_MS });
             if (response && (response.error === 'PACKAGE_NOT_FOUND' || response.error === 'ADD_FAILED') && !sub.endsWith('.umap')) {
                 const subWithExt = sub + '.umap';
                 response = await this.sendAutomationRequest('manage_level', {
@@ -560,7 +568,7 @@ export class LevelTools extends BaseTool {
                     subLevelPath: subWithExt,
                     parentPath: parent,
                     streamingMethod: params.streamingMethod
-                }, { timeoutMs: 30000 });
+                }, { timeoutMs: DEFAULT_OPERATION_TIMEOUT_MS });
             }
             if (response.success) {
                 this.ensureRecord(sub, { loaded: true, visible: true, streaming: true });
@@ -608,7 +616,7 @@ export class LevelTools extends BaseTool {
                 shouldBeLoaded: params.shouldBeLoaded,
                 shouldBeVisible
             }, {
-                timeoutMs: 60000
+                timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS
             });
             if (response.success === false) {
                 const errorCode = typeof response.error === 'string' ? response.error : '';

package/dist/tools/lighting.d.ts

@@ -19,8 +19,16 @@ export declare class LightingTools {
         castShadows?: boolean;
         temperature?: number;
         useAsAtmosphereSunLight?: boolean;
-        properties?: Record<string, any>;
-    }): Promise<any>;
+        properties?: Record<string, unknown>;
+    }): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+    }>;
     createPointLight(params: {
         name: string;
         location?: [number, number, number];
@@ -34,7 +42,15 @@ export declare class LightingTools {
             yaw: number;
             roll: number;
         };
-    }): Promise<any>;
+    }): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+    }>;
     createSpotLight(params: {
         name: string;
         location: [number, number, number];
@@ -49,7 +65,15 @@ export declare class LightingTools {
         radius?: number;
         color?: [number, number, number];
         castShadows?: boolean;
-    }): Promise<any>;
+    }): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+    }>;
     createRectLight(params: {
         name: string;
         location: [number, number, number];
@@ -63,7 +87,15 @@ export declare class LightingTools {
         intensity?: number;
         color?: [number, number, number];
         castShadows?: boolean;
-    }): Promise<any>;
+    }): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+    }>;
     createDynamicLight(params: {
         name?: string;
         lightType?: 'Point' | 'Spot' | 'Directional' | 'Rect' | string;
@@ -84,7 +116,15 @@ export declare class LightingTools {
             enabled?: boolean;
             frequency?: number;
         };
-    }): Promise<any>;
+    }): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+    }>;
     createSkyLight(params: {
         name: string;
         sourceType?: 'CapturedScene' | 'SpecifiedCubemap';
@@ -148,7 +188,14 @@ export declare class LightingTools {
         buildOnlySelected?: boolean;
         buildReflectionCaptures?: boolean;
         levelPath?: string;
-    }): Promise<any>;
+    }): Promise<{
+        success: boolean;
+        error: string;
+    } | {
+        success: boolean;
+        message: string;
+        error?: undefined;
+    }>;
     createLightingEnabledLevel(params?: {
         levelName?: string;
         copyActors?: boolean;

package/dist/tools/lighting.js

@@ -1,4 +1,5 @@
 import { ensureVector3 } from '../utils/validation.js';
+import { wasmIntegration } from '../wasm/index.js';
 export class LightingTools {
     bridge;
     automationBridge;
@@ -32,7 +33,10 @@ export class LightingTools {
                 name: params.name,
             };
             if (params.location) {
-                payload.location = { x: params.location[0], y: params.location[1], z: params.location[2] };
+                const zeroVector = [0, 0, 0];
+                const processedLocation = wasmIntegration.vectorAdd(zeroVector, params.location);
+                console.error('[WASM] Using vectorAdd for light positioning');
+                payload.location = { x: processedLocation[0], y: processedLocation[1], z: processedLocation[2] };
             }
             if (params.rotation) {
                 if (Array.isArray(params.rotation)) {
@@ -124,7 +128,7 @@ export class LightingTools {
             return { success: true, message: `Directional light '${name}' spawned` };
         }
         catch (e) {
-            return { success: false, error: `Failed to create directional light: ${e?.message ?? e}` };
+            return { success: false, error: `Failed to create directional light: ${(e instanceof Error ? e.message : String(e)) ?? e}` };
         }
     }
     async createPointLight(params) {
@@ -198,7 +202,7 @@ export class LightingTools {
             return { success: true, message: `Point light '${name}' spawned at ${location.join(', ')}` };
         }
         catch (e) {
-            return { success: false, error: `Failed to create point light: ${e?.message ?? e}` };
+            return { success: false, error: `Failed to create point light: ${(e instanceof Error ? e.message : String(e)) ?? e}` };
         }
     }
     async createSpotLight(params) {
@@ -298,7 +302,7 @@ export class LightingTools {
             return { success: true, message: `Spot light '${name}' spawned at ${params.location.join(', ')}` };
         }
         catch (e) {
-            return { success: false, error: `Failed to create spot light: ${e?.message ?? e}` };
+            return { success: false, error: `Failed to create spot light: ${(e instanceof Error ? e.message : String(e)) ?? e}` };
         }
     }
     async createRectLight(params) {
@@ -384,7 +388,7 @@ export class LightingTools {
             return { success: true, message: `Rect light '${name}' spawned at ${params.location.join(', ')}` };
         }
         catch (e) {
-            return { success: false, error: `Failed to create rect light: ${e?.message ?? e}` };
+            return { success: false, error: `Failed to create rect light: ${(e instanceof Error ? e.message : String(e)) ?? e}` };
         }
     }
     async createDynamicLight(params) {

package/dist/tools/materials.d.ts

@@ -43,7 +43,7 @@ export declare class MaterialTools {
         transport?: undefined;
         warnings?: undefined;
     }>;
-    createMaterialInstance(name: string, path: string, parentMaterial: string, parameters?: Record<string, any>): Promise<any>;
+    createMaterialInstance(name: string, path: string, parentMaterial: string, parameters?: Record<string, unknown>): Promise<any>;
     addNode(params: {
         materialPath: string;
         nodeType: string;

package/dist/tools/materials.js

@@ -129,7 +129,11 @@ export class MaterialTools {
                         return { success: false, error: resp?.error ?? resp?.message ?? 'CREATE_MATERIAL_INSTANCE_FAILED' };
                     }
                 }
-                catch (_e) {
+                catch (e) {
+                    const msg = e instanceof Error ? e.message : String(e);
+                    if (!msg.includes('unknown') && !msg.includes('UNKNOWN_PLUGIN_ACTION')) {
+                        console.warn(`[MaterialTools] Plugin create_material_instance failed with specific error (falling back to python): ${msg}`);
+                    }
                 }
             }
             const createParams = {

package/dist/tools/niagara.js

@@ -1,4 +1,5 @@
 import { sanitizeAssetName, validateAssetParams } from '../utils/validation.js';
+import { wasmIntegration } from '../wasm/index.js';
 export class NiagaraTools {
     bridge;
     automationBridge;
@@ -12,6 +13,16 @@ export class NiagaraTools {
             if (!this.automationBridge || typeof this.automationBridge.sendAutomationRequest !== 'function') {
                 throw new Error('Automation Bridge not available. Niagara system creation requires plugin support.');
             }
+            if (params.emitters) {
+                for (const emitter of params.emitters) {
+                    if (emitter.shapeSize) {
+                        const zeroVector = [0, 0, 0];
+                        const processedSize = wasmIntegration.vectorAdd(zeroVector, emitter.shapeSize);
+                        console.error('[WASM] Using vectorAdd for Niagara emitter shape size');
+                        emitter.shapeSize = [processedSize[0], processedSize[1], processedSize[2]];
+                    }
+                }
+            }
             const path = params.savePath || '/Game/Effects/Niagara';
             const response = await this.automationBridge.sendAutomationRequest('create_niagara_system', { name: params.name, savePath: path, template: params.template }, { timeoutMs: 60000 });
             if (response && response.success !== false) {
@@ -82,8 +93,19 @@ export class NiagaraTools {
             return [value.x ?? 0, value.y ?? 0, value.z ?? 0];
         };
         const requestPayload = { systemPath: params.systemPath };
-        const start = toVector(params.start);
-        const end = toVector(params.end);
+        let start = toVector(params.start);
+        let end = toVector(params.end);
+        const zeroVector = [0, 0, 0];
+        if (start) {
+            const processed = wasmIntegration.vectorAdd(zeroVector, start);
+            console.error('[WASM] Using vectorAdd for Niagara ribbon start');
+            start = [processed[0], processed[1], processed[2]];
+        }
+        if (end) {
+            const processed = wasmIntegration.vectorAdd(zeroVector, end);
+            console.error('[WASM] Using vectorAdd for Niagara ribbon end');
+            end = [processed[0], processed[1], processed[2]];
+        }
         if (start)
             requestPayload.start = start;
         if (end)
@@ -148,6 +170,19 @@ export class NiagaraTools {
         if (!this.automationBridge || typeof this.automationBridge.sendAutomationRequest !== 'function') {
             return { success: false, error: 'AUTOMATION_BRIDGE_UNAVAILABLE', message: 'addEmitter requires automation bridge' };
         }
+        if (params.properties) {
+            const zeroVector = [0, 0, 0];
+            if (params.properties.velocityMin) {
+                const processed = wasmIntegration.vectorAdd(zeroVector, params.properties.velocityMin);
+                console.error('[WASM] Using vectorAdd for Niagara velocity min');
+                params.properties.velocityMin = [processed[0], processed[1], processed[2]];
+            }
+            if (params.properties.velocityMax) {
+                const processed = wasmIntegration.vectorAdd(zeroVector, params.properties.velocityMax);
+                console.error('[WASM] Using vectorAdd for Niagara velocity max');
+                params.properties.velocityMax = [processed[0], processed[1], processed[2]];
+            }
+        }
         try {
             const resp = await this.automationBridge.sendAutomationRequest('manage_niagara_graph', {
                 subAction: 'add_emitter',

package/dist/tools/performance.d.ts

@@ -131,7 +131,6 @@ export declare class PerformanceTools {
     }>;
     optimizeDrawCalls(params: {
         enableInstancing?: boolean;
-        enableBatching?: boolean;
         mergeActors?: boolean;
         actors?: string[];
     }): Promise<{

package/dist/tools/performance.js

@@ -354,7 +354,6 @@ export class PerformanceTools {
                     }
                     const payload = {
                         enableInstancing: params.enableInstancing,
-                        enableBatching: params.enableBatching,
                         mergeActors: params.mergeActors,
                         actors: actors
                     };

package/dist/tools/physics.js

@@ -1,5 +1,6 @@
 import { validateAssetParams, resolveSkeletalMeshPath, concurrencyDelay } from '../utils/validation.js';
 import { coerceString, coerceStringArray } from '../utils/result-helpers.js';
+import { wasmIntegration } from '../wasm/index.js';
 export class PhysicsTools {
     bridge;
     automationBridge;
@@ -309,10 +310,13 @@ export class PhysicsTools {
             throw new Error('Automation Bridge not available. Physics force application requires plugin support.');
         }
         try {
+            const zeroVector = [0, 0, 0];
+            const normalizedVector = wasmIntegration.vectorAdd(zeroVector, params.vector);
+            console.error('[WASM] Using vectorAdd for physics force vector processing');
             const response = await this.automationBridge.sendAutomationRequest('apply_force', {
                 actorName: params.actorName,
                 forceType: params.forceType,
-                vector: params.vector,
+                vector: normalizedVector,
                 boneName: params.boneName,
                 isLocal: params.isLocal
             }, {

package/dist/tools/sequence.d.ts

@@ -1,5 +1,5 @@
 import { BaseTool } from './base-tool.js';
-import { ISequenceTools } from '../types/tool-interfaces.js';
+import { ISequenceTools, StandardActionResponse } from '../types/tool-interfaces.js';
 export interface LevelSequence {
     path: string;
     name: string;
@@ -28,80 +28,80 @@ export declare class SequenceTools extends BaseTool implements ISequenceTools {
         name: string;
         path?: string;
         timeoutMs?: number;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     open(params: {
         path: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     addCamera(params: {
         spawnable?: boolean;
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     addActor(params: {
         actorName: string;
         createBinding?: boolean;
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     play(params?: {
         path?: string;
         startTime?: number;
         loopMode?: 'once' | 'loop' | 'pingpong';
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     pause(params?: {
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     stop(params?: {
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     setSequenceProperties(params: {
         path?: string;
         frameRate?: number;
         lengthInFrames?: number;
         playbackStart?: number;
         playbackEnd?: number;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     setDisplayRate(params: {
         path?: string;
         frameRate: string | number;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     getSequenceProperties(params: {
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     setPlaybackSpeed(params: {
         speed: number;
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     getBindings(params?: {
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     addActors(params: {
         actorNames: string[];
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     removeActors(params: {
         actorNames: string[];
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     addSpawnableFromClass(params: {
         className: string;
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     list(params?: {
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     duplicate(params: {
         path: string;
         destinationPath: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     rename(params: {
         path: string;
         newName: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     deleteSequence(params: {
         path: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     getMetadata(params: {
         path?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     addKeyframe(params: {
         path?: string;
         bindingId?: string;
@@ -125,14 +125,14 @@ export declare class SequenceTools extends BaseTool implements ISequenceTools {
                 z: number;
             };
         };
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     listTracks(params: {
         path: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     setWorkRange(params: {
         path?: string;
         start: number;
         end: number;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
 }
 //# sourceMappingURL=sequence.d.ts.map

package/dist/tools/sequence.js

@@ -1,4 +1,5 @@
 import { BaseTool } from './base-tool.js';
+import { wasmIntegration } from '../wasm/index.js';
 export class SequenceTools extends BaseTool {
     sequenceCache = new Map();
     activeSequencePath;
@@ -214,6 +215,18 @@ export class SequenceTools extends BaseTool {
             frame: params.frame,
             value: params.value
         });
+        if (params.property === 'Transform' && params.value) {
+            const loc = params.value.location;
+            const rot = params.value.rotation;
+            const scale = params.value.scale;
+            if (loc && rot && scale) {
+                const locArr = [loc.x, loc.y, loc.z];
+                const rotArr = [rot.pitch, rot.yaw, rot.roll];
+                const scaleArr = [scale.x, scale.y, scale.z];
+                wasmIntegration.composeTransform(locArr, rotArr, scaleArr);
+                console.error('[WASM] Using composeTransform for keyframe validation');
+            }
+        }
         if (!resp.success && this.isUnknownActionResponse(resp)) {
             return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_add_keyframe' };
         }

package/dist/tools/ui.d.ts

@@ -69,7 +69,6 @@ export declare class UITools {
     setWidgetText(_params: {
         key: string;
         value: string;
-        componentName?: string;
     }): Promise<{
         success: boolean;
         message: string;
@@ -81,7 +80,6 @@ export declare class UITools {
     setWidgetImage(_params: {
         key: string;
         texturePath: string;
-        componentName?: string;
     }): Promise<{
         success: boolean;
         message: string;