unreal-engine-mcp-server 0.4.6 → 0.5.0

package/dist/tools/materials.js

@@ -1,29 +1,39 @@
-import { coerceBoolean, interpretStandardResult } from '../utils/result-helpers.js';
-import { escapePythonString } from '../utils/python.js';
 export class MaterialTools {
     bridge;
-    constructor(bridge) {
+    automationBridge;
+    constructor(bridge, automationBridge) {
         this.bridge = bridge;
+        this.automationBridge = automationBridge;
+    }
+    setAutomationBridge(automationBridge) {
+        this.automationBridge = automationBridge;
     }
     async createMaterial(name, path) {
         try {
-            if (!name || name.trim() === '') {
+            let effectiveName = name;
+            let effectivePath = path;
+            if (name && name.includes('/')) {
+                const lastSlashIndex = name.lastIndexOf('/');
+                effectiveName = name.substring(lastSlashIndex + 1);
+                const derivedPath = name.substring(0, lastSlashIndex);
+                if (!path || path === '/Game' || path === '') {
+                    effectivePath = derivedPath;
+                }
+            }
+            if (!effectiveName || effectiveName.trim() === '') {
                 return { success: false, error: 'Material name cannot be empty' };
             }
-            if (name.length > 100) {
-                return { success: false, error: `Material name too long (${name.length} chars). Maximum is 100 characters.` };
+            if (effectiveName.length > 100) {
+                return { success: false, error: `Material name too long (${effectiveName.length} chars). Maximum is 100 characters.` };
             }
             const invalidChars = /[\s./<>|{}[\]()@#\\]/;
-            if (invalidChars.test(name)) {
-                const foundChars = name.match(invalidChars);
+            if (invalidChars.test(effectiveName)) {
+                const foundChars = effectiveName.match(invalidChars);
                 return { success: false, error: `Material name contains invalid characters: '${foundChars?.[0]}'. Avoid spaces, dots, slashes, backslashes, brackets, and special symbols.` };
             }
-            if (typeof path !== 'string') {
-                return { success: false, error: `Invalid path type: expected string, got ${typeof path}` };
-            }
-            const trimmedPath = path.trim();
-            const effectivePath = trimmedPath.length === 0 ? '/Game' : trimmedPath;
-            const cleanPath = effectivePath.replace(/\/$/, '');
+            const trimmedPath = (effectivePath || '').trim();
+            const cleanPathStr = trimmedPath.length === 0 ? '/Game' : trimmedPath;
+            const cleanPath = cleanPathStr.replace(/\/$/, '');
             if (!cleanPath.startsWith('/Game') && !cleanPath.startsWith('/Engine')) {
                 return { success: false, error: `Invalid path: must start with /Game or /Engine, got ${cleanPath}` };
             }
@@ -33,104 +43,36 @@ export class MaterialTools {
                 const errorMessage = `Destination path is read-only and cannot be used for material creation: ${cleanPath}`;
                 return { success: false, error: errorMessage, message: errorMessage };
             }
-            const materialPath = `${cleanPath}/${name}`;
-            const payload = { name, cleanPath, materialPath };
-            const escapedName = escapePythonString(name);
-            const pythonCode = `
-import unreal, json
-
-payload = json.loads(r'''${JSON.stringify(payload)}''')
-result = {
-    'success': False,
-    'message': '',
-    'error': '',
-    'warnings': [],
-    'details': [],
-    'name': payload.get('name') or "${escapedName}",
-    'path': payload.get('materialPath')
-}
-
-material_path = result['path']
-clean_path = payload.get('cleanPath') or '/Game'
-
-try:
-    if unreal.EditorAssetLibrary.does_asset_exist(material_path):
-        result['success'] = True
-        result['exists'] = True
-        result['message'] = f"Material already exists at {material_path}"
-    else:
-        asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
-        factory = unreal.MaterialFactoryNew()
-        asset = asset_tools.create_asset(
-            asset_name=payload.get('name'),
-            package_path=clean_path,
-            asset_class=unreal.Material,
-            factory=factory
-        )
-        if asset:
-            unreal.EditorAssetLibrary.save_asset(material_path)
-            result['success'] = True
-            result['created'] = True
-            result['message'] = f"Material created at {material_path}"
-        else:
-            result['error'] = 'Failed to create material'
-            result['message'] = result['error']
-except Exception as exc:
-    result['error'] = str(exc)
-    if not result['message']:
-        result['message'] = result['error']
-
-print('RESULT:' + json.dumps(result))
-`.trim();
-            const pyResult = await this.bridge.executePython(pythonCode);
-            const interpreted = interpretStandardResult(pyResult, {
-                successMessage: `Material ${name} processed`,
-                failureMessage: 'Failed to create material'
-            });
-            if (interpreted.success) {
-                const exists = coerceBoolean(interpreted.payload.exists, false) === true;
-                const created = coerceBoolean(interpreted.payload.created, false) === true;
-                if (exists) {
-                    return { success: true, path: materialPath, message: `Material ${name} already exists at ${materialPath}` };
-                }
-                if (created) {
-                    return { success: true, path: materialPath, message: `Material ${name} created at ${materialPath}` };
+            const materialPath = `${cleanPath}/${effectiveName}`;
+            if (this.automationBridge && typeof this.automationBridge.sendAutomationRequest === 'function') {
+                try {
+                    const resp = await this.automationBridge.sendAutomationRequest('create_material', {
+                        name: effectiveName,
+                        destinationPath: cleanPath
+                    });
+                    if (resp && resp.success !== false) {
+                        return {
+                            success: true,
+                            path: resp.path || resp.result?.path || materialPath,
+                            message: resp.message || `Material ${name} created at ${materialPath}`,
+                            warnings: resp.warnings
+                        };
+                    }
+                    return {
+                        success: false,
+                        error: resp?.error ?? resp?.message ?? 'Failed to create material'
+                    };
                 }
-                return { success: true, path: materialPath, message: interpreted.message };
-            }
-            if (interpreted.error) {
-                const exists = await this.assetExists(materialPath);
-                if (exists) {
+                catch (err) {
                     return {
-                        success: true,
-                        path: materialPath,
-                        message: `Material ${name} created at ${materialPath}`,
-                        warnings: interpreted.warnings,
-                        details: interpreted.details
+                        success: false,
+                        error: `Failed to create material: ${err}`
                     };
                 }
-                return {
-                    success: false,
-                    error: interpreted.error,
-                    warnings: interpreted.warnings,
-                    details: interpreted.details
-                };
-            }
-            const exists = await this.assetExists(materialPath);
-            if (exists) {
-                return {
-                    success: true,
-                    path: materialPath,
-                    message: `Material ${name} created at ${materialPath}`,
-                    warnings: interpreted.warnings,
-                    details: interpreted.details
-                };
             }
             return {
                 success: false,
-                error: interpreted.message,
-                warnings: interpreted.warnings,
-                details: interpreted.details
+                error: 'Material creation requires Automation Bridge connection'
             };
         }
         catch (err) {
@@ -139,31 +81,161 @@ print('RESULT:' + json.dumps(result))
     }
     async applyMaterialToActor(actorPath, materialPath, slotIndex = 0) {
         try {
-            await this.bridge.httpCall('/remote/object/property', 'PUT', {
+            const result = await this.bridge.setObjectProperty({
                 objectPath: actorPath,
                 propertyName: `StaticMeshComponent.Materials[${slotIndex}]`,
-                propertyValue: materialPath
+                value: materialPath
             });
-            return { success: true, message: 'Material applied' };
+            if (result.success) {
+                return {
+                    success: true,
+                    message: 'Material applied',
+                    transport: result.transport,
+                    warnings: Array.isArray(result.warnings) ? result.warnings : undefined
+                };
+            }
+            return {
+                success: false,
+                error: result.error ?? `Failed to apply material to ${actorPath}`,
+                transport: result.transport
+            };
         }
         catch (err) {
             return { success: false, error: `Failed to apply material: ${err}` };
         }
     }
-    async assetExists(assetPath) {
+    async createMaterialInstance(name, path, parentMaterial, parameters) {
         try {
-            const response = await this.bridge.call({
-                objectPath: '/Script/EditorScriptingUtilities.Default__EditorAssetLibrary',
-                functionName: 'DoesAssetExist',
-                parameters: {
-                    AssetPath: assetPath
+            if (!name || name.trim() === '') {
+                return { success: false, error: 'Material instance name cannot be empty' };
+            }
+            const cleanPath = (path || '/Game').replace(/\/$/, '');
+            if (!cleanPath.startsWith('/Game') && !cleanPath.startsWith('/Engine')) {
+                return { success: false, error: `Invalid path: must start with /Game or /Engine, got ${cleanPath}` };
+            }
+            if (this.automationBridge && typeof this.automationBridge.sendAutomationRequest === 'function') {
+                try {
+                    const resp = await this.automationBridge.sendAutomationRequest('create_material_instance', {
+                        name,
+                        destinationPath: cleanPath,
+                        parentMaterial,
+                        parameters
+                    });
+                    if (resp && resp.success !== false) {
+                        return { success: true, path: resp.path || resp.result?.path || `${cleanPath}/${name}`, message: resp.message || `Material instance ${name} created at ${cleanPath}/${name}`, warnings: resp.warnings };
+                    }
+                    const errTxt = String(resp?.error ?? resp?.message ?? '');
+                    if (!(errTxt.toLowerCase().includes('unknown') || errTxt.includes('UNKNOWN_PLUGIN_ACTION'))) {
+                        return { success: false, error: resp?.error ?? resp?.message ?? 'CREATE_MATERIAL_INSTANCE_FAILED' };
+                    }
                 }
-            });
-            return coerceBoolean(response?.ReturnValue ?? response?.Result ?? response, false) === true;
+                catch (_e) {
+                }
+            }
+            const createParams = {
+                asset_name: name,
+                package_path: cleanPath,
+                factory_class: 'MaterialInstanceConstantFactoryNew',
+                asset_class: 'MaterialInstanceConstant',
+                parent_material: parentMaterial,
+                parameters: parameters || {}
+            };
+            try {
+                const res = await this.bridge.executeEditorFunction('CREATE_ASSET', createParams);
+                if (res && res.success !== false) {
+                    const createdPath = res.path || res.result?.path || `${cleanPath}/${name}`;
+                    if (parentMaterial) {
+                        try {
+                            await this.bridge.setObjectProperty({ objectPath: createdPath, propertyName: 'parent', value: parentMaterial, markDirty: true });
+                        }
+                        catch (_) {
+                        }
+                    }
+                    try {
+                        await this.bridge.executeEditorFunction('SAVE_ASSET', { path: createdPath });
+                    }
+                    catch (_) { }
+                    return { success: true, path: createdPath, message: `Material instance ${name} created at ${createdPath}` };
+                }
+                const errTxt = String(res?.error ?? res?.message ?? '');
+                if (errTxt.toLowerCase().includes('unknown') || errTxt.includes('UNKNOWN_PLUGIN_ACTION')) {
+                    return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement create_material_instance' };
+                }
+                return { success: false, error: res?.error ?? res?.message ?? 'CREATE_MATERIAL_INSTANCE_FAILED' };
+            }
+            catch (err) {
+                return { success: false, error: String(err) || 'CREATE_MATERIAL_INSTANCE_FAILED' };
+            }
         }
-        catch {
-            return false;
+        catch (err) {
+            return { success: false, error: `Failed to create material instance: ${err}` };
         }
     }
+    async addNode(params) {
+        if (!params.materialPath)
+            return { success: false, error: 'INVALID_MATERIAL_PATH', message: 'Material path is required' };
+        if (!params.nodeType)
+            return { success: false, error: 'INVALID_NODE_TYPE', message: 'Node type is required' };
+        const res = await this.automationBridge?.sendAutomationRequest('manage_material_graph', {
+            subAction: 'add_node',
+            assetPath: params.materialPath,
+            nodeType: params.nodeType,
+            x: params.x,
+            y: params.y,
+            name: params.name
+        });
+        return res;
+    }
+    async removeNode(params) {
+        if (!params.materialPath)
+            return { success: false, error: 'INVALID_MATERIAL_PATH', message: 'Material 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_material_graph', {
+            subAction: 'remove_node',
+            assetPath: params.materialPath,
+            nodeId: params.nodeId
+        });
+        return res;
+    }
+    async connectNodes(params) {
+        if (!params.materialPath)
+            return { success: false, error: 'INVALID_MATERIAL_PATH', message: 'Material path is required' };
+        if (!params.sourceNodeId)
+            return { success: false, error: 'INVALID_SOURCE_NODE', message: 'Source node ID is required' };
+        if (!params.inputName)
+            return { success: false, error: 'INVALID_INPUT_NAME', message: 'Input name is required' };
+        const res = await this.automationBridge?.sendAutomationRequest('manage_material_graph', {
+            subAction: 'connect_nodes',
+            assetPath: params.materialPath,
+            sourceNodeId: params.sourceNodeId,
+            targetNodeId: params.targetNodeId,
+            inputName: params.inputName
+        });
+        return res;
+    }
+    async breakConnections(params) {
+        if (!params.materialPath)
+            return { success: false, error: 'INVALID_MATERIAL_PATH', message: 'Material 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_material_graph', {
+            subAction: 'break_connections',
+            assetPath: params.materialPath,
+            nodeId: params.nodeId,
+            pinName: params.pinName
+        });
+        return res;
+    }
+    async getNodeDetails(params) {
+        if (!params.materialPath)
+            return { success: false, error: 'INVALID_MATERIAL_PATH', message: 'Material path is required' };
+        const res = await this.automationBridge?.sendAutomationRequest('manage_material_graph', {
+            subAction: 'get_node_details',
+            assetPath: params.materialPath,
+            nodeId: params.nodeId
+        });
+        return res;
+    }
 }
 //# sourceMappingURL=materials.js.map

package/dist/tools/niagara.d.ts

@@ -1,10 +1,10 @@
 import { UnrealBridge } from '../unreal-bridge.js';
+import { AutomationBridge } from '../automation/index.js';
 export declare class NiagaraTools {
     private bridge;
-    constructor(bridge: UnrealBridge);
-    /**
-     * Create Niagara System (real asset via Python)
-     */
+    private automationBridge?;
+    constructor(bridge: UnrealBridge, automationBridge?: AutomationBridge | undefined);
+    setAutomationBridge(automationBridge?: AutomationBridge): void;
     createSystem(params: {
         name: string;
         savePath?: string;
@@ -17,19 +17,99 @@ export declare class NiagaraTools {
             shapeSize?: [number, number, number];
         }>;
     }): Promise<{
-        success: boolean;
-        error: string;
+        readonly success: true;
+        readonly systemName: string;
+        readonly path: string;
+        readonly message: any;
+        error?: undefined;
+    } | {
+        readonly success: false;
+        readonly error: any;
+        readonly message: any;
+        systemName?: undefined;
+        path?: undefined;
+    } | {
+        readonly success: false;
+        readonly error: `Failed to create Niagara system: ${string}`;
+        systemName?: undefined;
         path?: undefined;
         message?: undefined;
+    }>;
+    createEmitter(params: {
+        name: string;
+        savePath?: string;
+        systemPath?: string;
+        template?: string;
+    }): Promise<{
+        readonly success: true;
+        readonly emitterPath: any;
+        readonly emitterName: any;
+        readonly message: any;
+        error?: undefined;
     } | {
-        success: boolean;
-        path: string;
-        message: string;
+        readonly success: false;
+        readonly error: any;
+        readonly message: any;
+        readonly emitterPath?: undefined;
+        emitterName?: undefined;
+    } | {
+        readonly success: false;
+        readonly error: `Failed to create Niagara emitter: ${string}`;
+        readonly emitterPath?: undefined;
+        emitterName?: undefined;
+        message?: undefined;
+    }>;
+    createRibbon(params: {
+        systemPath: string;
+        start?: {
+            x: number;
+            y: number;
+            z: number;
+        } | [number, number, number];
+        end?: {
+            x: number;
+            y: number;
+            z: number;
+        } | [number, number, number];
+        color?: [number, number, number, number];
+        width?: number;
+    }): Promise<{
+        readonly success: true;
+        readonly ribbonPath: any;
+        readonly message: any;
         error?: undefined;
+    } | {
+        readonly success: false;
+        readonly error: any;
+        readonly message: any;
+        readonly ribbonPath?: undefined;
+    } | {
+        readonly success: false;
+        readonly error: `Failed to create Niagara ribbon: ${string}`;
+        readonly ribbonPath?: undefined;
+        message?: undefined;
+    }>;
+    cleanupEffects(params: {
+        filter: string;
+    }): Promise<{
+        readonly success: true;
+        readonly removed: any;
+        readonly removedActors: string[];
+        readonly message: any;
+        error?: undefined;
+    } | {
+        readonly success: false;
+        readonly error: any;
+        readonly message: any;
+        readonly removed?: undefined;
+        readonly removedActors?: undefined;
+    } | {
+        readonly success: false;
+        readonly error: `Failed to cleanup Niagara effects: ${string}`;
+        readonly removed?: undefined;
+        readonly removedActors?: undefined;
+        message?: undefined;
     }>;
-    /**
-     * Add Emitter to System (left as-is; console commands may be placeholders)
-     */
     addEmitter(params: {
         systemName: string;
         emitterName: string;
@@ -45,32 +125,72 @@ export declare class NiagaraTools {
             mesh?: string;
         };
     }): Promise<{
+        readonly success: false;
+        readonly error: "AUTOMATION_BRIDGE_UNAVAILABLE";
+        readonly message: "addEmitter requires automation bridge";
+        emitterId?: undefined;
+    } | {
         success: boolean;
-        message: string;
+        message: any;
+        emitterId: any;
         error?: undefined;
     } | {
         success: boolean;
-        error: string;
-        message?: undefined;
+        error: any;
+        message: any;
+        emitterId?: undefined;
     }>;
+    addModule(params: {
+        systemPath: string;
+        modulePath: string;
+        emitterName?: string;
+        scriptType?: 'Spawn' | 'Update';
+        timeoutMs?: number;
+    }): Promise<import("../automation/types.js").AutomationBridgeResponseMessage | {
+        readonly success: false;
+        readonly error: "INVALID_SYSTEM_PATH";
+        readonly message: "System path is required";
+    } | {
+        readonly success: false;
+        readonly error: "INVALID_MODULE_PATH";
+        readonly message: "Module path is required";
+    } | undefined>;
+    connectPins(params: {
+        systemPath: string;
+        fromNodeId: string;
+        fromPinName: string;
+        toNodeId: string;
+        toPinName: string;
+        emitterName?: string;
+        scriptType?: 'Spawn' | 'Update';
+        timeoutMs?: number;
+    }): Promise<import("../automation/types.js").AutomationBridgeResponseMessage | {
+        readonly success: false;
+        readonly error: "INVALID_SYSTEM_PATH";
+        readonly message: "System path is required";
+    } | undefined>;
+    removeNode(params: {
+        systemPath: string;
+        nodeId: string;
+        emitterName?: string;
+        scriptType?: 'Spawn' | 'Update';
+        timeoutMs?: number;
+    }): Promise<import("../automation/types.js").AutomationBridgeResponseMessage | {
+        readonly success: false;
+        readonly error: "INVALID_SYSTEM_PATH";
+        readonly message: "System path is required";
+    } | {
+        readonly success: false;
+        readonly error: "INVALID_NODE_ID";
+        readonly message: "Node ID is required";
+    } | undefined>;
     setParameter(params: {
         systemName: string;
         parameterName: string;
         parameterType: 'Float' | 'Vector' | 'Color' | 'Bool' | 'Int';
         value: any;
         isUserParameter?: boolean;
-    }): Promise<{
-        success: boolean;
-        message: string;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        message?: undefined;
-    }>;
-    /**
-     * Create Preset Effect (now creates a real Niagara system asset)
-     */
+    }): Promise<any>;
     createEffect(params: {
         effectType: 'Fire' | 'Smoke' | 'Explosion' | 'Water' | 'Rain' | 'Snow' | 'Magic' | 'Lightning' | 'Dust' | 'Steam';
         name: string;
@@ -86,7 +206,7 @@ export declare class NiagaraTools {
         };
     }): Promise<{
         success: boolean;
-        error: string;
+        error: any;
         message?: undefined;
         path?: undefined;
     } | {
@@ -117,9 +237,6 @@ export declare class NiagaraTools {
         message?: undefined;
         path?: undefined;
     }>;
-    /**
-     * Spawn Niagara Effect in Level using Python (NiagaraActor)
-     */
     spawnEffect(params: {
         systemPath: string;
         location: [number, number, number] | {
@@ -131,13 +248,6 @@ export declare class NiagaraTools {
         scale?: [number, number, number] | number;
         autoDestroy?: boolean;
         attachToActor?: string;
-    }): Promise<{
-        success: true;
-        message: string;
-        actor?: string;
-    } | {
-        success: boolean;
-        error: string;
-    }>;
+    }): Promise<any>;
 }
 //# sourceMappingURL=niagara.d.ts.map