unreal-engine-mcp-server 0.4.7 → 0.5.0

package/dist/tools/logs.d.ts

@@ -14,11 +14,11 @@ type Entry = {
     message: string;
 };
 export declare class LogTools {
-    private bridge;
+    private _bridge;
     private env;
-    private log;
+    private _log;
     private cachedLogPath?;
-    constructor(bridge: UnrealBridge);
+    constructor(_bridge: UnrealBridge);
     readOutputLog(params: ReadParams): Promise<{
         success: boolean;
         error: string;

package/dist/tools/logs.js

@@ -3,14 +3,15 @@ import { Logger } from '../utils/logger.js';
 import { promises as fs } from 'fs';
 import path from 'path';
 export class LogTools {
-    bridge;
+    _bridge;
     env = loadEnv();
-    log = new Logger('LogTools');
+    _log = new Logger('LogTools');
     cachedLogPath;
-    constructor(bridge) {
-        this.bridge = bridge;
+    constructor(_bridge) {
+        this._bridge = _bridge;
     }
     async readOutputLog(params) {
+        this._log.debug('Reading output log', { params, connected: this._bridge.isConnected });
         const target = await this.resolveLogPath(params.logPath);
         if (!target) {
             return { success: false, error: 'Log file not found' };
@@ -74,59 +75,6 @@ export class LogTools {
         if (envLog) {
             return envLog;
         }
-        if (this.bridge.isConnected) {
-            try {
-                const script = `
-import unreal, json, os
-paths = []
-try:
-    d = unreal.Paths.project_log_dir()
-    if d:
-        paths.append(os.path.abspath(d))
-except Exception:
-    pass
-try:
-    sd = unreal.Paths.project_saved_dir()
-    if sd:
-        p = os.path.join(sd, 'Logs')
-        paths.append(os.path.abspath(p))
-except Exception:
-    pass
-try:
-    pf = unreal.Paths.get_project_file_path()
-    if pf:
-        pd = os.path.dirname(pf)
-        p = os.path.join(pd, 'Saved', 'Logs')
-        paths.append(os.path.abspath(p))
-except Exception:
-    pass
-all_logs = []
-for base in paths:
-    try:
-        if os.path.isdir(base):
-            for name in os.listdir(base):
-                if name.lower().endswith('.log'):
-                    fp = os.path.join(base, name)
-                    try:
-                        m = os.path.getmtime(fp)
-                        all_logs.append({'p': fp, 'm': m})
-                    except Exception:
-                        pass
-    except Exception:
-        pass
-all_logs.sort(key=lambda x: x['m'], reverse=True)
-print('RESULT:' + json.dumps({'dirs': paths, 'logs': all_logs}))
-`.trim();
-                const res = await this.bridge.executePythonWithResult(script);
-                const logs = Array.isArray(res?.logs) ? res.logs : [];
-                for (const entry of logs) {
-                    const p = typeof entry?.p === 'string' ? entry.p : undefined;
-                    if (p && p.trim())
-                        return this.cacheLogPath(p);
-                }
-            }
-            catch { }
-        }
         const fallback = await this.findLatestLogInDir(path.join(process.cwd(), 'Saved', 'Logs'));
         if (fallback) {
             return fallback;

package/dist/tools/materials.d.ts

@@ -1,52 +1,119 @@
 import { UnrealBridge } from '../unreal-bridge.js';
+import { AutomationBridge } from '../automation/index.js';
 export declare class MaterialTools {
     private bridge;
-    constructor(bridge: UnrealBridge);
+    private automationBridge?;
+    constructor(bridge: UnrealBridge, automationBridge?: AutomationBridge | undefined);
+    setAutomationBridge(automationBridge?: AutomationBridge): void;
     createMaterial(name: string, path: string): Promise<{
-        success: boolean;
-        error: string;
-        message?: undefined;
-        path?: undefined;
-        warnings?: undefined;
-        details?: undefined;
-    } | {
         success: boolean;
         error: string;
         message: string;
         path?: undefined;
         warnings?: undefined;
-        details?: undefined;
     } | {
         success: boolean;
-        path: string;
-        message: string;
-        error?: undefined;
-        warnings?: undefined;
-        details?: undefined;
-    } | {
-        success: boolean;
-        path: string;
-        message: string;
-        warnings: string[] | undefined;
-        details: string[] | undefined;
+        path: any;
+        message: any;
+        warnings: any;
         error?: undefined;
     } | {
         success: boolean;
-        error: string;
-        warnings: string[] | undefined;
-        details: string[] | undefined;
+        error: any;
         message?: undefined;
         path?: undefined;
+        warnings?: undefined;
     }>;
     applyMaterialToActor(actorPath: string, materialPath: string, slotIndex?: number): Promise<{
         success: boolean;
         message: string;
+        transport: any;
+        warnings: any[] | undefined;
         error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        transport: any;
+        message?: undefined;
+        warnings?: undefined;
     } | {
         success: boolean;
         error: string;
         message?: undefined;
+        transport?: undefined;
+        warnings?: undefined;
     }>;
-    private assetExists;
+    createMaterialInstance(name: string, path: string, parentMaterial: string, parameters?: Record<string, any>): Promise<any>;
+    addNode(params: {
+        materialPath: string;
+        nodeType: string;
+        x: number;
+        y: number;
+        name?: string;
+        timeoutMs?: number;
+    }): Promise<import("../automation/types.js").AutomationBridgeResponseMessage | {
+        readonly success: false;
+        readonly error: "INVALID_MATERIAL_PATH";
+        readonly message: "Material path is required";
+    } | {
+        readonly success: false;
+        readonly error: "INVALID_NODE_TYPE";
+        readonly message: "Node type is required";
+    } | undefined>;
+    removeNode(params: {
+        materialPath: string;
+        nodeId: string;
+        timeoutMs?: number;
+    }): Promise<import("../automation/types.js").AutomationBridgeResponseMessage | {
+        readonly success: false;
+        readonly error: "INVALID_MATERIAL_PATH";
+        readonly message: "Material path is required";
+    } | {
+        readonly success: false;
+        readonly error: "INVALID_NODE_ID";
+        readonly message: "Node ID is required";
+    } | undefined>;
+    connectNodes(params: {
+        materialPath: string;
+        sourceNodeId: string;
+        targetNodeId: string;
+        inputName: string;
+        timeoutMs?: number;
+    }): Promise<import("../automation/types.js").AutomationBridgeResponseMessage | {
+        readonly success: false;
+        readonly error: "INVALID_MATERIAL_PATH";
+        readonly message: "Material path is required";
+    } | {
+        readonly success: false;
+        readonly error: "INVALID_SOURCE_NODE";
+        readonly message: "Source node ID is required";
+    } | {
+        readonly success: false;
+        readonly error: "INVALID_INPUT_NAME";
+        readonly message: "Input name is required";
+    } | undefined>;
+    breakConnections(params: {
+        materialPath: string;
+        nodeId: string;
+        pinName?: string;
+        timeoutMs?: number;
+    }): Promise<import("../automation/types.js").AutomationBridgeResponseMessage | {
+        readonly success: false;
+        readonly error: "INVALID_MATERIAL_PATH";
+        readonly message: "Material path is required";
+    } | {
+        readonly success: false;
+        readonly error: "INVALID_NODE_ID";
+        readonly message: "Node ID is required";
+    } | undefined>;
+    getNodeDetails(params: {
+        materialPath: string;
+        nodeId?: string;
+        timeoutMs?: number;
+    }): Promise<import("../automation/types.js").AutomationBridgeResponseMessage | {
+        readonly success: false;
+        readonly error: "INVALID_MATERIAL_PATH";
+        readonly message: "Material path is required";
+    } | undefined>;
 }
 //# sourceMappingURL=materials.d.ts.map

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