unreal-engine-mcp-server 0.4.6 → 0.5.0

package/src/tools/logs.ts

@@ -0,0 +1,219 @@
+import { UnrealBridge } from '../unreal-bridge.js';
+import { loadEnv } from '../types/env.js';
+import { Logger } from '../utils/logger.js';
+import { promises as fs } from 'fs';
+import path from 'path';
+
+type ReadParams = {
+  filterCategory?: string[]
+  filterLevel?: 'Error' | 'Warning' | 'Log' | 'Verbose' | 'VeryVerbose' | 'All'
+  lines?: number
+  logPath?: string
+  includePrefixes?: string[]
+  excludeCategories?: string[]
+}
+
+type Entry = {
+  timestamp?: string
+  category?: string
+  level?: string
+  message: string
+}
+
+export class LogTools {
+  private env = loadEnv();
+  private _log = new Logger('LogTools');
+  private cachedLogPath?: string;
+  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' };
+    }
+    const maxLines = typeof params.lines === 'number' && params.lines > 0 ? Math.min(params.lines, 2000) : 200;
+    let text = '';
+    try {
+      text = await this.tailFile(target, maxLines);
+    } catch (err: any) {
+      return { success: false, error: String(err?.message || err) };
+    }
+    const rawLines = text.split(/\r?\n/).filter(l => l.length > 0);
+    const parsed: Entry[] = rawLines.map(l => this.parseLine(l));
+    const mappedLevel = params.filterLevel || 'All';
+    const includeCats = Array.isArray(params.filterCategory) && params.filterCategory.length ? new Set(params.filterCategory) : undefined;
+    const includePrefixes = Array.isArray(params.includePrefixes) && params.includePrefixes.length ? params.includePrefixes : undefined;
+    const excludeCats = Array.isArray(params.excludeCategories) && params.excludeCategories.length ? new Set(params.excludeCategories) : undefined;
+    const filtered = parsed.filter(e => {
+      if (!e) return false;
+      if (mappedLevel && mappedLevel !== 'All') {
+        const lv = (e.level || 'Log');
+        if (lv === 'Display') {
+          if (mappedLevel !== 'Log') return false;
+        } else if (lv !== mappedLevel) {
+          return false;
+        }
+      }
+      if (includeCats && e.category && !includeCats.has(e.category)) return false;
+      if (includePrefixes && includePrefixes.length && e.category) {
+        if (!includePrefixes.some(p => (e.category ?? '').startsWith(p))) return false;
+      }
+      if (excludeCats && e.category && excludeCats.has(e.category)) return false;
+      return true;
+    });
+    const includeInternal = Boolean(
+      (includeCats && includeCats.has('LogPython')) ||
+      (includePrefixes && includePrefixes.some(p => 'LogPython'.startsWith(p)))
+    );
+    const sanitized = includeInternal ? filtered : filtered.filter(entry => !this.isInternalLogEntry(entry));
+    return { success: true, logPath: target.replace(/\\/g, '/'), entries: sanitized, filteredCount: sanitized.length };
+  }
+
+  private async resolveLogPath(override?: string): Promise<string | undefined> {
+    if (override && typeof override === 'string' && override.trim()) {
+      try {
+        const st = await fs.stat(override);
+        if (st.isFile()) {
+          return this.cacheLogPath(path.resolve(override));
+        }
+      } catch { }
+    }
+
+    if (this.cachedLogPath && (await this.fileExists(this.cachedLogPath))) {
+      return this.cachedLogPath;
+    }
+
+    const envLog = await this.resolveFromProjectEnv();
+    if (envLog) {
+      return envLog;
+    }
+
+    // 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;
+    }
+    return undefined;
+  }
+
+  private async resolveFromProjectEnv(): Promise<string | undefined> {
+    const projectPath = this.env.UE_PROJECT_PATH;
+    if (projectPath && typeof projectPath === 'string' && projectPath.trim()) {
+      const projectDir = path.dirname(projectPath);
+      const logsDir = path.join(projectDir, 'Saved', 'Logs');
+      const envLog = await this.findLatestLogInDir(logsDir);
+      if (envLog) {
+        return envLog;
+      }
+    }
+    return undefined;
+  }
+
+  private async findLatestLogInDir(dir: string): Promise<string | undefined> {
+    if (!dir) return undefined;
+    try {
+      const entries = await fs.readdir(dir);
+      const candidates: { p: string; m: number }[] = [];
+      for (const name of entries) {
+        if (!name.toLowerCase().endsWith('.log')) continue;
+        const fp = path.join(dir, name);
+        try {
+          const st = await fs.stat(fp);
+          candidates.push({ p: fp, m: st.mtimeMs });
+        } catch { }
+      }
+      if (candidates.length) {
+        candidates.sort((a, b) => b.m - a.m);
+        return this.cacheLogPath(candidates[0].p);
+      }
+    } catch { }
+    return undefined;
+  }
+
+  private async fileExists(filePath: string): Promise<boolean> {
+    try {
+      const st = await fs.stat(filePath);
+      return st.isFile();
+    } catch {
+      return false;
+    }
+  }
+
+  private cacheLogPath(p: string): string {
+    this.cachedLogPath = p;
+    return p;
+  }
+
+  private async tailFile(filePath: string, maxLines: number): Promise<string> {
+    const handle = await fs.open(filePath, 'r');
+    try {
+      const stat = await handle.stat();
+      const chunkSize = 128 * 1024;
+      let position = stat.size;
+      let remaining = '';
+      const lines: string[] = [];
+      while (position > 0 && lines.length < maxLines) {
+        const readSize = Math.min(chunkSize, position);
+        position -= readSize;
+        const buf = Buffer.alloc(readSize);
+        await handle.read(buf, 0, readSize, position);
+        remaining = buf.toString('utf8') + remaining;
+        const parts = remaining.split(/\r?\n/);
+        remaining = parts.shift() || '';
+        while (parts.length) {
+          const line = parts.pop() as string;
+          if (line === undefined) break;
+          if (line.length === 0) continue;
+          lines.unshift(line);
+          if (lines.length >= maxLines) break;
+        }
+      }
+      if (lines.length < maxLines && remaining) {
+        lines.unshift(remaining);
+      }
+      return lines.slice(0, maxLines).join('\n');
+    } finally {
+      try { await handle.close(); } catch { }
+    }
+  }
+
+  private parseLine(line: string): Entry {
+    const m1 = line.match(/^\[?(\d{4}\.\d{2}\.\d{2}-\d{2}\.\d{2}\.\d{2}:\d+)\]?\s*\[(.*?)\]\s*(.*)$/);
+    if (m1) {
+      const rest = m1[3];
+      const m2 = rest.match(/^(\w+):\s*(Error|Warning|Display|Log|Verbose|VeryVerbose):\s*(.*)$/);
+      if (m2) {
+        return { timestamp: m1[1], category: m2[1], level: m2[2] === 'Display' ? 'Log' : m2[2], message: m2[3] };
+      }
+      const m3 = rest.match(/^(\w+):\s*(.*)$/);
+      if (m3) {
+        return { timestamp: m1[1], category: m3[1], level: 'Log', message: m3[2] };
+      }
+      return { timestamp: m1[1], message: rest };
+    }
+    const m = line.match(/^(\w+):\s*(Error|Warning|Display|Log|Verbose|VeryVerbose):\s*(.*)$/);
+    if (m) {
+      return { category: m[1], level: m[2] === 'Display' ? 'Log' : m[2], message: m[3] };
+    }
+    const mAlt = line.match(/^(\w+):\s*(.*)$/);
+    if (mAlt) {
+      return { category: mAlt[1], level: 'Log', message: mAlt[2] };
+    }
+    return { message: line };
+  }
+
+  private isInternalLogEntry(entry: Entry): boolean {
+    if (!entry) return false;
+    const category = entry.category?.toLowerCase() || '';
+    const message = entry.message?.trim() || '';
+    if (category === 'logpython' && message.startsWith('RESULT:')) {
+      return true;
+    }
+    if (!entry.category && message.startsWith('[') && message.includes('LogPython: RESULT:')) {
+      return true;
+    }
+    return false;
+  }
+}

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;
+  }
 }