unreal-engine-mcp-server 0.4.7 → 0.5.0

package/src/tools/logs.ts

@@ -22,11 +22,12 @@ type Entry = {
 
 export class LogTools {
   private env = loadEnv();
-  private log = new Logger('LogTools');
+  private _log = new Logger('LogTools');
   private cachedLogPath?: string;
-  constructor(private bridge: UnrealBridge) {}
+  constructor(private _bridge: UnrealBridge) { }
 
   async readOutputLog(params: ReadParams) {
+    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' };
@@ -76,7 +77,7 @@ export class LogTools {
         if (st.isFile()) {
           return this.cacheLogPath(path.resolve(override));
         }
-      } catch {}
+      } catch { }
     }
 
     if (this.cachedLogPath && (await this.fileExists(this.cachedLogPath))) {
@@ -88,57 +89,8 @@ export class LogTools {
       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 {}
-    }
+    // TODO: Restore Python path resolution once executePythonWithResult is available in UnrealBridge
+    // Currently relying on UE_PROJECT_PATH or cwd fallback
     const fallback = await this.findLatestLogInDir(path.join(process.cwd(), 'Saved', 'Logs'));
     if (fallback) {
       return fallback;
@@ -170,13 +122,13 @@ print('RESULT:' + json.dumps({'dirs': paths, 'logs': all_logs}))
         try {
           const st = await fs.stat(fp);
           candidates.push({ p: fp, m: st.mtimeMs });
-        } catch {}
+        } catch { }
       }
       if (candidates.length) {
         candidates.sort((a, b) => b.m - a.m);
         return this.cacheLogPath(candidates[0].p);
       }
-    } catch {}
+    } catch { }
     return undefined;
   }
 
@@ -223,7 +175,7 @@ print('RESULT:' + json.dumps({'dirs': paths, 'logs': all_logs}))
       }
       return lines.slice(0, maxLines).join('\n');
     } finally {
-      try { await handle.close(); } catch {}
+      try { await handle.close(); } catch { }
     }
   }
 

package/src/tools/materials.ts

@@ -1,33 +1,46 @@
 import { UnrealBridge } from '../unreal-bridge.js';
-import { coerceBoolean, interpretStandardResult } from '../utils/result-helpers.js';
-import { escapePythonString } from '../utils/python.js';
+import { AutomationBridge } from '../automation/index.js';
 
 export class MaterialTools {
-  constructor(private bridge: UnrealBridge) {}
+  constructor(private bridge: UnrealBridge, private automationBridge?: AutomationBridge) { }
+
+  setAutomationBridge(automationBridge?: AutomationBridge) {
+    this.automationBridge = automationBridge;
+  }
 
   async createMaterial(name: string, path: string) {
     try {
-      if (!name || name.trim() === '') {
+      // Support unified assetPath in 'name' argument
+      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 was not provided or is just root, prefer the derived path
+        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}` };
@@ -40,109 +53,40 @@ export class MaterialTools {
         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')
-}
+      const materialPath = `${cleanPath}/${effectiveName}`;
 
-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'
-      });
+      // Use Automation Bridge for material creation
+      if (this.automationBridge && typeof this.automationBridge.sendAutomationRequest === 'function') {
+        try {
+          const resp: any = await this.automationBridge.sendAutomationRequest('create_material', {
+            name: effectiveName,
+            destinationPath: cleanPath
+          });
 
-      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}` };
-        }
-        return { success: true, path: materialPath, message: interpreted.message };
-      }
+          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
+            };
+          }
 
-      if (interpreted.error) {
-        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
+            success: false,
+            error: resp?.error ?? resp?.message ?? 'Failed to create material'
+          };
+        } catch (err) {
+          return {
+            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) {
       return { success: false, error: `Failed to create material: ${err}` };
@@ -151,29 +95,195 @@ print('RESULT:' + json.dumps(result))
 
   async applyMaterialToActor(actorPath: string, materialPath: string, 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}` };
     }
   }
 
-  private async assetExists(assetPath: string): Promise<boolean> {
+  async createMaterialInstance(name: string, path: string, parentMaterial: string, parameters?: Record<string, any>) {
     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}` };
+      }
+
+      // Plugin-first attempt
+      if (this.automationBridge && typeof this.automationBridge.sendAutomationRequest === 'function') {
+        try {
+          const resp: any = 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 } as any;
+          }
+          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' } as any;
+          }
+        } catch (_e) {
+          // fall back to python path below
         }
-      });
-      return coerceBoolean(response?.ReturnValue ?? response?.Result ?? response, false) === true;
-    } catch {
-      return false;
+      }
+
+      // Fallback: use the centralized editor function template for material instance
+      const createParams = {
+        asset_name: name,
+        package_path: cleanPath,
+        factory_class: 'MaterialInstanceConstantFactoryNew',
+        asset_class: 'MaterialInstanceConstant',
+        parent_material: parentMaterial,
+        parameters: parameters || {}
+      };
+
+      // Try a plugin-native asset creation path via executeEditorFunction
+      try {
+        const res = await this.bridge.executeEditorFunction('CREATE_ASSET', createParams);
+        if (res && res.success !== false) {
+          const createdPath = res.path || res.result?.path || `${cleanPath}/${name}`;
+          // Attempt to set parent via plugin-native setObjectProperty when available
+          if (parentMaterial) {
+            try {
+              await this.bridge.setObjectProperty({ objectPath: createdPath, propertyName: 'parent', value: parentMaterial, markDirty: true });
+            } catch (_) {
+              // Ignore failure to set parent - template may have already set it
+            }
+          }
+          // Save asset (plugin-first via SAVE_ASSET template)
+          try {
+            await this.bridge.executeEditorFunction('SAVE_ASSET', { path: createdPath });
+          } catch (_) { }
+          return { success: true, path: createdPath, message: `Material instance ${name} created at ${createdPath}` } as any;
+        }
+        // If plugin indicated unknown action and python fallback not allowed, surface explicit failure
+        const errTxt = String((res as any)?.error ?? (res as any)?.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' } as any;
+        }
+        return { success: false, error: (res as any)?.error ?? (res as any)?.message ?? 'CREATE_MATERIAL_INSTANCE_FAILED' } as any;
+      } catch (err) {
+        // If executeEditorFunction threw due to bridge not connected or python disabled,
+        // preserve previous behavior by returning structured failure.
+        return { success: false, error: String(err) || 'CREATE_MATERIAL_INSTANCE_FAILED' } as any;
+      }
+    } catch (err) {
+      return { success: false, error: `Failed to create material instance: ${err}` };
     }
   }
+  async addNode(params: {
+    materialPath: string;
+    nodeType: string;
+    x: number;
+    y: number;
+    name?: string; // For parameter nodes
+    timeoutMs?: number;
+  }) {
+    if (!params.materialPath) return { success: false, error: 'INVALID_MATERIAL_PATH', message: 'Material path is required' } as const;
+    if (!params.nodeType) return { success: false, error: 'INVALID_NODE_TYPE', message: 'Node type is required' } as const;
+
+    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: {
+    materialPath: string;
+    nodeId: string;
+    timeoutMs?: number;
+  }) {
+    if (!params.materialPath) return { success: false, error: 'INVALID_MATERIAL_PATH', message: 'Material path is required' } as const;
+    if (!params.nodeId) return { success: false, error: 'INVALID_NODE_ID', message: 'Node ID is required' } as const;
+
+    const res = await this.automationBridge?.sendAutomationRequest('manage_material_graph', {
+      subAction: 'remove_node',
+      assetPath: params.materialPath,
+      nodeId: params.nodeId
+    });
+    return res;
+  }
+
+  async connectNodes(params: {
+    materialPath: string;
+    sourceNodeId: string;
+    targetNodeId: string; // Use 'Main' for main material node
+    inputName: string; // Input pin name on target
+    timeoutMs?: number;
+  }) {
+    if (!params.materialPath) return { success: false, error: 'INVALID_MATERIAL_PATH', message: 'Material path is required' } as const;
+    if (!params.sourceNodeId) return { success: false, error: 'INVALID_SOURCE_NODE', message: 'Source node ID is required' } as const;
+    if (!params.inputName) return { success: false, error: 'INVALID_INPUT_NAME', message: 'Input name is required' } as const;
+
+    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: {
+    materialPath: string;
+    nodeId: string;
+    pinName?: string;
+    timeoutMs?: number;
+  }) {
+    if (!params.materialPath) return { success: false, error: 'INVALID_MATERIAL_PATH', message: 'Material path is required' } as const;
+    if (!params.nodeId) return { success: false, error: 'INVALID_NODE_ID', message: 'Node ID is required' } as const;
+
+    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: {
+    materialPath: string;
+    nodeId?: string; // If omitted, lists all nodes
+    timeoutMs?: number;
+  }) {
+    if (!params.materialPath) return { success: false, error: 'INVALID_MATERIAL_PATH', message: 'Material path is required' } as const;
+
+    const res = await this.automationBridge?.sendAutomationRequest('manage_material_graph', {
+      subAction: 'get_node_details',
+      assetPath: params.materialPath,
+      nodeId: params.nodeId
+    });
+    return res;
+  }
 }