unreal-engine-mcp-server 0.5.4 → 0.5.5

package/src/tools/logs.ts

@@ -1,219 +0,0 @@
-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,295 +0,0 @@
-import { UnrealBridge } from '../unreal-bridge.js';
-import { AutomationBridge } from '../automation/index.js';
-
-export class MaterialTools {
-  constructor(private bridge: UnrealBridge, private automationBridge?: AutomationBridge) { }
-
-  setAutomationBridge(automationBridge?: AutomationBridge) {
-    this.automationBridge = automationBridge;
-  }
-
-  async createMaterial(name: string, path: string) {
-    try {
-      // 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 (effectiveName.length > 100) {
-        return { success: false, error: `Material name too long (${effectiveName.length} chars). Maximum is 100 characters.` };
-      }
-
-      const invalidChars = /[\s./<>|{}[\]()@#\\]/;
-      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.` };
-      }
-
-      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}` };
-      }
-
-      const normalizedPath = cleanPath.toLowerCase();
-      const restrictedPrefixes = ['/engine/restricted', '/engine/generated', '/engine/transient'];
-      if (restrictedPrefixes.some(prefix => normalizedPath.startsWith(prefix))) {
-        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}/${effectiveName}`;
-
-      // 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 (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'
-          };
-        } catch (err) {
-          return {
-            success: false,
-            error: `Failed to create material: ${err}`
-          };
-        }
-      }
-
-      return {
-        success: false,
-        error: 'Material creation requires Automation Bridge connection'
-      };
-    } catch (err) {
-      return { success: false, error: `Failed to create material: ${err}` };
-    }
-  }
-
-  async applyMaterialToActor(actorPath: string, materialPath: string, slotIndex = 0) {
-    try {
-      const result = await this.bridge.setObjectProperty({
-        objectPath: actorPath,
-        propertyName: `StaticMeshComponent.Materials[${slotIndex}]`,
-        value: materialPath
-      });
-
-      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 createMaterialInstance(name: string, path: string, parentMaterial: string, parameters?: Record<string, unknown>) {
-    try {
-      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) {
-          // If the error is simply generic or unknown action, we fall back.
-          // But if it's a specific error, we might log it.
-          // For now, let's at least not silence everything.
-          const msg = e instanceof Error ? e.message : String(e);
-          if (!msg.includes('unknown') && !msg.includes('UNKNOWN_PLUGIN_ACTION')) {
-            console.warn(`[MaterialTools] Plugin create_material_instance failed with specific error (falling back to python): ${msg}`);
-          }
-        }
-      }
-
-      // 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;
-  }
-}