unreal-engine-mcp-server 0.4.6 → 0.5.0

package/dist/tools/niagara.js

@@ -1,145 +1,249 @@
 import { sanitizeAssetName, validateAssetParams } from '../utils/validation.js';
-import { interpretStandardResult, coerceString } from '../utils/result-helpers.js';
 export class NiagaraTools {
     bridge;
-    constructor(bridge) {
+    automationBridge;
+    constructor(bridge, automationBridge) {
         this.bridge = bridge;
+        this.automationBridge = automationBridge;
     }
-    /**
-     * Create Niagara System (real asset via Python)
-     */
+    setAutomationBridge(automationBridge) { this.automationBridge = automationBridge; }
     async createSystem(params) {
         try {
+            if (!this.automationBridge || typeof this.automationBridge.sendAutomationRequest !== 'function') {
+                throw new Error('Automation Bridge not available. Niagara system creation requires plugin support.');
+            }
             const path = params.savePath || '/Game/Effects/Niagara';
-            const python = `
-import unreal
-import json
-
-path = r"${path}"
-name = r"${params.name}"
-full_path = f"{path}/{name}"
-
-if unreal.EditorAssetLibrary.does_asset_exist(full_path):
-    print('RESULT:' + json.dumps({'success': True, 'path': full_path, 'existing': True}))
-else:
-    asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
-    factory = None
-    try:
-        factory = unreal.NiagaraSystemFactoryNew()
-    except Exception:
-        factory = None
-
-    if factory is None:
-        print('RESULT:' + json.dumps({'success': False, 'error': 'NiagaraSystemFactoryNew unavailable'}))
-    else:
-        asset = asset_tools.create_asset(asset_name=name, package_path=path, asset_class=unreal.NiagaraSystem, factory=factory)
-        if asset:
-            unreal.EditorAssetLibrary.save_asset(full_path)
-            print('RESULT:' + json.dumps({'success': True, 'path': full_path}))
-        else:
-            print('RESULT:' + json.dumps({'success': False, 'error': 'AssetTools create_asset failed'}))
-`.trim();
-            const resp = await this.bridge.executePython(python);
-            const interpreted = interpretStandardResult(resp, {
-                successMessage: `Niagara system ${params.name} created`,
-                failureMessage: `Failed to create Niagara system ${params.name}`
-            });
-            if (!interpreted.success) {
-                return { success: false, error: interpreted.error ?? interpreted.message };
+            const response = await this.automationBridge.sendAutomationRequest('create_niagara_system', { name: params.name, savePath: path, template: params.template }, { timeoutMs: 60000 });
+            if (response && response.success !== false) {
+                const result = response.result ?? {};
+                const systemName = result.systemName ?? params.name;
+                const systemPath = response.path ?? result.systemPath ?? result.path ?? `${path}/${params.name}`;
+                return {
+                    success: true,
+                    systemName,
+                    path: systemPath,
+                    message: response.message || result.message || `Niagara system ${systemName} created`
+                };
             }
-            const pathFromPayload = coerceString(interpreted.payload.path) ?? `${path}/${params.name}`;
             return {
-                success: true,
-                path: pathFromPayload,
-                message: interpreted.message
+                success: false,
+                error: response?.error ?? 'CREATE_NIAGARA_SYSTEM_FAILED',
+                message: response?.message ?? 'Niagara system creation failed'
             };
         }
-        catch (err) {
-            return { success: false, error: `Failed to create Niagara system: ${err}` };
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { success: false, error: `Failed to create Niagara system: ${message}` };
+        }
+    }
+    async createEmitter(params) {
+        if (!this.automationBridge || typeof this.automationBridge.sendAutomationRequest !== 'function') {
+            return { success: false, error: 'AUTOMATION_BRIDGE_UNAVAILABLE', message: 'createEmitter requires automation bridge' };
+        }
+        const requestPayload = {
+            name: params.name,
+            savePath: params.savePath ?? '/Game/Effects/Niagara'
+        };
+        if (params.systemPath)
+            requestPayload.systemPath = params.systemPath;
+        if (params.template)
+            requestPayload.template = params.template;
+        try {
+            const response = await this.automationBridge.sendAutomationRequest('create_niagara_emitter', requestPayload, { timeoutMs: 60000 });
+            if (response && response.success !== false) {
+                const result = response.result ?? {};
+                return {
+                    success: true,
+                    emitterPath: response.emitterPath ?? result.emitterPath ?? result.path,
+                    emitterName: result.emitterName ?? params.name,
+                    message: response.message || result.message || `Niagara emitter ${params.name} created`
+                };
+            }
+            return {
+                success: false,
+                error: response?.error ?? 'CREATE_NIAGARA_EMITTER_FAILED',
+                message: response?.message ?? 'Niagara emitter creation failed'
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { success: false, error: `Failed to create Niagara emitter: ${message}` };
+        }
+    }
+    async createRibbon(params) {
+        if (!this.automationBridge || typeof this.automationBridge.sendAutomationRequest !== 'function') {
+            return { success: false, error: 'AUTOMATION_BRIDGE_UNAVAILABLE', message: 'createRibbon requires automation bridge' };
+        }
+        const toVector = (value) => {
+            if (!value)
+                return undefined;
+            if (Array.isArray(value))
+                return [value[0] ?? 0, value[1] ?? 0, value[2] ?? 0];
+            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);
+        if (start)
+            requestPayload.start = start;
+        if (end)
+            requestPayload.end = end;
+        if (params.color)
+            requestPayload.color = params.color;
+        if (typeof params.width === 'number')
+            requestPayload.width = params.width;
+        try {
+            const response = await this.automationBridge.sendAutomationRequest('create_niagara_ribbon', requestPayload, { timeoutMs: 60000 });
+            if (response && response.success !== false) {
+                const result = response.result ?? {};
+                return {
+                    success: true,
+                    ribbonPath: response.ribbonPath ?? result.ribbonPath ?? result.path,
+                    message: response.message || result.message || 'Niagara ribbon created'
+                };
+            }
+            return {
+                success: false,
+                error: response?.error ?? 'CREATE_NIAGARA_RIBBON_FAILED',
+                message: response?.message ?? 'Niagara ribbon creation failed'
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { success: false, error: `Failed to create Niagara ribbon: ${message}` };
+        }
+    }
+    async cleanupEffects(params) {
+        if (!this.automationBridge || typeof this.automationBridge.sendAutomationRequest !== 'function') {
+            return { success: false, error: 'AUTOMATION_BRIDGE_UNAVAILABLE', message: 'cleanupEffects requires automation bridge' };
+        }
+        if (!params.filter || typeof params.filter !== 'string') {
+            return { success: false, error: 'INVALID_ARGUMENT', message: 'filter is required' };
+        }
+        try {
+            const response = await this.automationBridge.sendAutomationRequest('cleanup', { filter: params.filter }, { timeoutMs: 60000 });
+            if (response && response.success !== false) {
+                const result = response.result ?? {};
+                const removedActors = result.removedActors ?? response.removedActors ?? [];
+                const removedCount = result.removed ?? removedActors.length;
+                return {
+                    success: true,
+                    removed: removedCount,
+                    removedActors,
+                    message: response.message || result.message || `Cleanup completed (removed=${removedCount})`
+                };
+            }
+            return {
+                success: false,
+                error: response?.error ?? 'CLEANUP_FAILED',
+                message: response?.message ?? 'Niagara cleanup failed'
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { success: false, error: `Failed to cleanup Niagara effects: ${message}` };
         }
     }
-    /**
-     * Add Emitter to System (left as-is; console commands may be placeholders)
-     */
     async addEmitter(params) {
+        if (!this.automationBridge || typeof this.automationBridge.sendAutomationRequest !== 'function') {
+            return { success: false, error: 'AUTOMATION_BRIDGE_UNAVAILABLE', message: 'addEmitter requires automation bridge' };
+        }
         try {
-            const commands = [
-                `AddNiagaraEmitter ${params.systemName} ${params.emitterName} ${params.emitterType}`
-            ];
-            if (params.properties) {
-                const props = params.properties;
-                if (props.spawnRate !== undefined) {
-                    commands.push(`SetEmitterSpawnRate ${params.systemName} ${params.emitterName} ${props.spawnRate}`);
-                }
-                if (props.lifetime !== undefined) {
-                    commands.push(`SetEmitterLifetime ${params.systemName} ${params.emitterName} ${props.lifetime}`);
-                }
-                if (props.velocityMin && props.velocityMax) {
-                    const min = props.velocityMin;
-                    const max = props.velocityMax;
-                    commands.push(`SetEmitterVelocity ${params.systemName} ${params.emitterName} ${min[0]} ${min[1]} ${min[2]} ${max[0]} ${max[1]} ${max[2]}`);
-                }
-                if (props.size !== undefined) {
-                    commands.push(`SetEmitterSize ${params.systemName} ${params.emitterName} ${props.size}`);
-                }
-                if (props.color) {
-                    const color = props.color;
-                    commands.push(`SetEmitterColor ${params.systemName} ${params.emitterName} ${color[0]} ${color[1]} ${color[2]} ${color[3]}`);
-                }
-                if (props.material) {
-                    commands.push(`SetEmitterMaterial ${params.systemName} ${params.emitterName} ${props.material}`);
-                }
-                if (props.mesh && params.emitterType === 'Mesh') {
-                    commands.push(`SetEmitterMesh ${params.systemName} ${params.emitterName} ${props.mesh}`);
-                }
+            const resp = await this.automationBridge.sendAutomationRequest('manage_niagara_graph', {
+                subAction: 'add_emitter',
+                systemName: params.systemName,
+                emitterName: params.emitterName,
+                emitterType: params.emitterType,
+                properties: params.properties
+            });
+            if (resp && resp.success !== false) {
+                return {
+                    success: true,
+                    message: resp.message || `Emitter ${params.emitterName} added to ${params.systemName}`,
+                    emitterId: resp.result?.emitterId
+                };
             }
-            await this.bridge.executeConsoleCommands(commands);
-            return { success: true, message: `Emitter ${params.emitterName} added to ${params.systemName}` };
+            return {
+                success: false,
+                error: resp?.error || 'ADD_EMITTER_FAILED',
+                message: resp?.message || 'Failed to add emitter'
+            };
         }
-        catch (err) {
-            return { success: false, error: `Failed to add emitter: ${err}` };
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            return { success: false, error: 'ADD_EMITTER_FAILED', message };
         }
     }
+    async addModule(params) {
+        if (!params.systemPath)
+            return { success: false, error: 'INVALID_SYSTEM_PATH', message: 'System path is required' };
+        if (!params.modulePath)
+            return { success: false, error: 'INVALID_MODULE_PATH', message: 'Module path is required' };
+        const res = await this.automationBridge?.sendAutomationRequest('manage_niagara_graph', {
+            subAction: 'add_module',
+            assetPath: params.systemPath,
+            modulePath: params.modulePath,
+            emitterName: params.emitterName,
+            scriptType: params.scriptType
+        });
+        return res;
+    }
+    async connectPins(params) {
+        if (!params.systemPath)
+            return { success: false, error: 'INVALID_SYSTEM_PATH', message: 'System path is required' };
+        const res = await this.automationBridge?.sendAutomationRequest('manage_niagara_graph', {
+            subAction: 'connect_pins',
+            assetPath: params.systemPath,
+            fromNode: params.fromNodeId,
+            fromPin: params.fromPinName,
+            toNode: params.toNodeId,
+            toPin: params.toPinName,
+            emitterName: params.emitterName,
+            scriptType: params.scriptType
+        });
+        return res;
+    }
+    async removeNode(params) {
+        if (!params.systemPath)
+            return { success: false, error: 'INVALID_SYSTEM_PATH', message: 'System path is required' };
+        if (!params.nodeId)
+            return { success: false, error: 'INVALID_NODE_ID', message: 'Node ID is required' };
+        const res = await this.automationBridge?.sendAutomationRequest('manage_niagara_graph', {
+            subAction: 'remove_node',
+            assetPath: params.systemPath,
+            nodeId: params.nodeId,
+            emitterName: params.emitterName,
+            scriptType: params.scriptType
+        });
+        return res;
+    }
     async setParameter(params) {
         try {
-            const paramType = params.isUserParameter ? 'User' : 'System';
-            let valueStr = '';
-            switch (params.parameterType) {
-                case 'Float':
-                case 'Int':
-                case 'Bool':
-                    valueStr = String(params.value);
-                    break;
-                case 'Vector': {
-                    const v = params.value;
-                    valueStr = `${v[0]} ${v[1]} ${v[2]}`;
-                    break;
-                }
-                case 'Color': {
-                    const c = params.value;
-                    valueStr = `${c[0]} ${c[1]} ${c[2]} ${c[3] || 1}`;
-                    break;
-                }
+            const automationBridge = this.bridge.automationBridge;
+            if (!automationBridge) {
+                return { success: false, error: 'Automation bridge not available' };
             }
-            const command = `SetNiagara${paramType}Parameter ${params.systemName} ${params.parameterName} ${params.parameterType} ${valueStr}`;
-            await this.bridge.executeConsoleCommand(command);
-            return { success: true, message: `Parameter ${params.parameterName} set on ${params.systemName}` };
+            const resp = await automationBridge.sendAutomationRequest('set_niagara_parameter', {
+                systemName: params.systemName,
+                parameterName: params.parameterName,
+                parameterType: params.parameterType,
+                value: params.value,
+                isUserParameter: params.isUserParameter === true
+            });
+            if (resp && resp.success !== false)
+                return { success: true, message: resp.message || `Parameter ${params.parameterName} set on ${params.systemName}`, applied: resp.applied ?? resp.result?.applied };
+            return { success: false, message: resp?.message ?? 'Set parameter failed', error: resp?.error ?? 'SET_PARAMETER_FAILED' };
         }
         catch (err) {
             return { success: false, error: `Failed to set parameter: ${err}` };
         }
     }
-    /**
-     * Create Preset Effect (now creates a real Niagara system asset)
-     */
     async createEffect(params) {
         try {
-            // Validate effect type at runtime (inputs can come from JSON)
-            const allowedTypes = ['Fire', 'Smoke', 'Explosion', 'Water', 'Rain', 'Snow', 'Magic', 'Lightning', 'Dust', 'Steam'];
+            const allowedTypes = ['Fire', 'Smoke', 'Explosion', 'Water', 'Rain', 'Snow', 'Magic', 'Lightning', 'Dust', 'Steam', 'Default'];
             if (!params || !allowedTypes.includes(String(params.effectType))) {
                 return { success: false, error: `Invalid effectType: ${String(params?.effectType)}` };
             }
-            // Sanitize and validate name and path
             const defaultPath = '/Game/Effects/Niagara';
             const nameToUse = sanitizeAssetName(params.name);
             const validation = validateAssetParams({ name: nameToUse, savePath: defaultPath });
@@ -149,31 +253,10 @@ else:
             const safeName = validation.sanitized.name;
             const savePath = validation.sanitized.savePath || defaultPath;
             const fullPath = `${savePath}/${safeName}`;
-            // Create or ensure the Niagara system asset exists
             const createRes = await this.createSystem({ name: safeName, savePath, template: 'Empty' });
             if (!createRes.success) {
                 return { success: false, error: createRes.error || 'Failed creating Niagara system' };
             }
-            // Verify existence via Python to avoid RC EditorAssetLibrary issues
-            const verifyPy = `
-import unreal
-import json
-
-p = r"${fullPath}"
-exists = bool(unreal.EditorAssetLibrary.does_asset_exist(p))
-print('RESULT:' + json.dumps({'success': True, 'exists': exists}))
-`.trim();
-            const verifyResp = await this.bridge.executePython(verifyPy);
-            const verifyResult = interpretStandardResult(verifyResp, {
-                successMessage: 'Niagara asset verification complete',
-                failureMessage: `Failed to verify Niagara asset at ${fullPath}`
-            });
-            if (!verifyResult.success) {
-                return { success: false, error: verifyResult.error ?? verifyResult.message };
-            }
-            if (verifyResult.payload.exists === false) {
-                return { success: false, error: `Asset not found after creation: ${fullPath}` };
-            }
             return { success: true, message: `${params.effectType} effect ${safeName} created`, path: fullPath };
         }
         catch (err) {
@@ -204,62 +287,29 @@ print('RESULT:' + json.dumps({'success': True, 'exists': exists}))
             return { success: false, error: `Failed to create GPU simulation: ${err}` };
         }
     }
-    /**
-     * Spawn Niagara Effect in Level using Python (NiagaraActor)
-     */
     async spawnEffect(params) {
         try {
             const loc = Array.isArray(params.location) ? { x: params.location[0], y: params.location[1], z: params.location[2] } : params.location;
-            const rot = params.rotation || [0, 0, 0];
-            const scl = Array.isArray(params.scale) ? params.scale : (typeof params.scale === 'number' ? [params.scale, params.scale, params.scale] : [1, 1, 1]);
-            const py = `
-import unreal
-import json
-
-loc = unreal.Vector(${loc.x || 0}, ${loc.y || 0}, ${loc.z || 0})
-rot = unreal.Rotator(${rot[0]}, ${rot[1]}, ${rot[2]})
-scale = unreal.Vector(${scl[0]}, ${scl[1]}, ${scl[2]})
-sys_path = r"${params.systemPath}"
-
-if unreal.EditorAssetLibrary.does_asset_exist(sys_path):
-  sys = unreal.EditorAssetLibrary.load_asset(sys_path)
-  actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-  actor = actor_subsystem.spawn_actor_from_class(unreal.NiagaraActor, loc, rot)
-  if actor:
-    comp = actor.get_niagara_component()
-    try:
-      comp.set_asset(sys)
-    except Exception:
-      try:
-        comp.set_editor_property('asset', sys)
-      except Exception:
-        pass
-    comp.set_world_scale3d(scale)
-    comp.activate(True)
-    actor.set_actor_label(f"Niagara_{unreal.SystemLibrary.get_game_time_in_seconds(actor.get_world()):.0f}")
-    print('RESULT:' + json.dumps({'success': True, 'actor': actor.get_actor_label()}))
-  else:
-    print('RESULT:' + json.dumps({'success': False, 'error': 'Failed to spawn NiagaraActor'}))
-else:
-  print('RESULT:' + json.dumps({'success': False, 'error': 'System asset not found'}))
-`.trim();
-            const resp = await this.bridge.executePython(py);
-            const interpreted = interpretStandardResult(resp, {
-                successMessage: 'Niagara effect spawned',
-                failureMessage: 'Failed to spawn Niagara effect'
-            });
-            const actorLabel = coerceString(interpreted.payload.actor);
-            if (!interpreted.success) {
-                return { success: false, error: interpreted.error ?? interpreted.message };
-            }
-            const outcome = {
-                success: true,
-                message: interpreted.message
-            };
-            if (actorLabel) {
-                outcome.actor = actorLabel;
+            if (this.automationBridge && typeof this.automationBridge.sendAutomationRequest === 'function') {
+                try {
+                    const resp = await this.automationBridge.sendAutomationRequest('spawn_niagara', {
+                        systemPath: params.systemPath,
+                        location: [loc.x ?? 0, loc.y ?? 0, loc.z ?? 0],
+                        rotation: params.rotation,
+                        scale: params.scale,
+                        autoDestroy: params.autoDestroy,
+                        attachToActor: params.attachToActor
+                    });
+                    if (resp && resp.success !== false) {
+                        return { success: true, message: resp.message || 'Niagara effect spawned', actor: resp.actor || resp.result?.actor || resp.result?.actorName };
+                    }
+                    return { success: false, message: resp?.message ?? 'Spawn failed', error: resp?.error ?? 'SPAWN_FAILED' };
+                }
+                catch (error) {
+                    return { success: false, error: `Failed to spawn effect: ${error instanceof Error ? error.message : String(error)}` };
+                }
             }
-            return outcome;
+            throw new Error('Automation Bridge not available. Niagara effect spawning requires plugin support.');
         }
         catch (err) {
             return { success: false, error: `Failed to spawn effect: ${err}` };

package/dist/tools/performance.d.ts

@@ -1,7 +1,11 @@
 import { UnrealBridge } from '../unreal-bridge.js';
+import { AutomationBridge } from '../automation/index.js';
 export declare class PerformanceTools {
     private bridge;
-    constructor(bridge: UnrealBridge);
+    private log;
+    private automationBridge?;
+    constructor(bridge: UnrealBridge, automationBridge?: AutomationBridge);
+    setAutomationBridge(automationBridge?: AutomationBridge): void;
     startProfiling(params: {
         type: 'CPU' | 'GPU' | 'Memory' | 'RenderThread' | 'GameThread' | 'All';
         duration?: number;
@@ -17,6 +21,12 @@ export declare class PerformanceTools {
         enabled: boolean;
         verbose?: boolean;
     }): Promise<{
+        success: boolean;
+        message: string;
+        fpsVisible: boolean;
+        command?: undefined;
+        error?: undefined;
+    } | {
         success: boolean;
         message: string;
         fpsVisible: boolean;
@@ -38,25 +48,19 @@ export declare class PerformanceTools {
         level: 0 | 1 | 2 | 3 | 4;
     }): Promise<{
         success: boolean;
-        error: string;
-        message?: undefined;
-        verified?: undefined;
-        readback?: undefined;
+        message: string;
+        error?: undefined;
         method?: undefined;
     } | {
         success: boolean;
-        message: string;
-        verified: boolean;
-        readback: number;
-        method: string;
-        error?: undefined;
+        error: string;
+        message?: undefined;
+        method?: undefined;
     } | {
         success: boolean;
         message: string;
         method: string;
         error?: undefined;
-        verified?: undefined;
-        readback?: undefined;
     }>;
     setResolutionScale(params: {
         scale: number;
@@ -86,6 +90,11 @@ export declare class PerformanceTools {
     }): Promise<{
         success: boolean;
         message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
     }>;
     configureTextureStreaming(params: {
         enabled: boolean;
@@ -124,9 +133,15 @@ export declare class PerformanceTools {
         enableInstancing?: boolean;
         enableBatching?: boolean;
         mergeActors?: boolean;
+        actors?: string[];
     }): Promise<{
+        success: boolean;
+        error: string;
+        message?: undefined;
+    } | {
         success: boolean;
         message: string;
+        error?: undefined;
     }>;
     configureOcclusionCulling(params: {
         enabled: boolean;