unreal-engine-mcp-server 0.5.0 → 0.5.2

package/src/tools/level.ts

@@ -1,5 +1,13 @@
 import { BaseTool } from './base-tool.js';
-import { ILevelTools } from '../types/tool-interfaces.js';
+import { ILevelTools, StandardActionResponse } from '../types/tool-interfaces.js';
+import { LevelResponse } from '../types/automation-responses.js';
+import { wasmIntegration as _wasmIntegration } from '../wasm/index.js';
+import { sanitizePath } from '../utils/path-security.js';
+import {
+  DEFAULT_OPERATION_TIMEOUT_MS,
+  DEFAULT_ASSET_OP_TIMEOUT_MS,
+  LONG_RUNNING_OP_TIMEOUT_MS
+} from '../constants.js';
 
 type LevelExportRecord = { target: string; timestamp: number; note?: string };
 type ManagedLevelRecord = {
@@ -38,6 +46,18 @@ export class LevelTools extends BaseTool implements ILevelTools {
     if (!formatted.startsWith('/Game/')) {
       formatted = `/Game/${formatted.replace(/^\/+/, '')}`;
     }
+
+    // Security validation
+    try {
+      formatted = sanitizePath(formatted);
+    } catch (e: unknown) {
+      // If sanitizePath fails, we should probably propagate that error, 
+      // but normalizeLevelPath signature expects to return an object.
+      // For now, let's log and rethrow or fallback? 
+      // Throwing is safer as it prevents operation on invalid path.
+      throw new Error(`Security validation failed for level path: ${e instanceof Error ? e.message : String(e)}`);
+    }
+
     formatted = formatted.replace(/\.umap$/i, '');
     if (formatted.endsWith('/')) {
       formatted = formatted.slice(0, -1);
@@ -205,10 +225,10 @@ export class LevelTools extends BaseTool implements ILevelTools {
     this.ensureRecord(normalized.path, { loaded: true, visible: true });
   }
 
-  async listLevels() {
+  async listLevels(): Promise<StandardActionResponse> {
     // Try to get actual levels from UE via automation bridge
     try {
-      const response = await this.sendAutomationRequest('list_levels', {}, {
+      const response = await this.sendAutomationRequest<LevelResponse>('list_levels', {}, {
         timeoutMs: 10000
       });
 
@@ -222,6 +242,7 @@ export class LevelTools extends BaseTool implements ILevelTools {
         const finalLevels = [...ueLevels, ...managedOnly];
 
         const result: Record<string, unknown> = {
+          ...response,
           success: true,
           message: 'Levels listed from Unreal Engine',
           levels: finalLevels,
@@ -232,12 +253,11 @@ export class LevelTools extends BaseTool implements ILevelTools {
             levels: finalLevels,
             count: finalLevels.length
           },
-          ...response,
           managedLevels: managed.levels,
           managedLevelCount: managed.count
         };
 
-        return result;
+        return result as StandardActionResponse;
       }
     } catch {
       // Fall back to managed levels if automation bridge fails
@@ -247,12 +267,12 @@ export class LevelTools extends BaseTool implements ILevelTools {
     return this.listManagedLevels();
   }
 
-  async getLevelSummary(levelPath?: string) {
+  async getLevelSummary(levelPath?: string): Promise<StandardActionResponse> {
     const resolved = this.resolveLevelPath(levelPath);
     if (!resolved) {
       return { success: false, error: 'No level specified' };
     }
-    return this.summarizeLevel(resolved);
+    return this.summarizeLevel(resolved) as StandardActionResponse;
   }
 
   registerLight(levelPath: string | undefined, info: { name: string; type: string; details?: Record<string, unknown> }) {
@@ -272,27 +292,27 @@ export class LevelTools extends BaseTool implements ILevelTools {
     });
   }
 
-  async exportLevel(params: { levelPath?: string; exportPath: string; note?: string; timeoutMs?: number }) {
+  async exportLevel(params: { levelPath?: string; exportPath: string; note?: string; timeoutMs?: number }): Promise<StandardActionResponse> {
     const resolved = this.resolveLevelPath(params.levelPath);
     if (!resolved) {
       return { success: false, error: 'No level specified for export' };
     }
 
     try {
-      const res = await this.sendAutomationRequest('manage_level', {
+      const res = await this.sendAutomationRequest<LevelResponse>('manage_level', {
         action: 'export_level',
         levelPath: resolved,
         exportPath: params.exportPath
-      }, { timeoutMs: params.timeoutMs ?? 300000 });
+      }, { timeoutMs: params.timeoutMs ?? LONG_RUNNING_OP_TIMEOUT_MS });
 
-      if ((res as any)?.success === false) {
+      if (res?.success === false) {
         return {
           success: false,
-          error: (res as any).error || (res as any).message || 'Export failed',
+          error: res.error || res.message || 'Export failed',
           levelPath: resolved,
           exportPath: params.exportPath,
           details: res
-        };
+        } as StandardActionResponse;
       }
 
       return {
@@ -301,23 +321,23 @@ export class LevelTools extends BaseTool implements ILevelTools {
         levelPath: resolved,
         exportPath: params.exportPath,
         details: res
-      };
-    } catch (e: any) {
-      return { success: false, error: `Export failed: ${e.message}` };
+      } as StandardActionResponse;
+    } catch (e: unknown) {
+      return { success: false, error: `Export failed: ${e instanceof Error ? e.message : String(e)}` };
     }
   }
 
-  async importLevel(params: { packagePath: string; destinationPath?: string; streaming?: boolean; timeoutMs?: number }) {
+  async importLevel(params: { packagePath: string; destinationPath?: string; streaming?: boolean; timeoutMs?: number }): Promise<StandardActionResponse> {
     const destination = params.destinationPath
       ? this.normalizeLevelPath(params.destinationPath)
       : this.normalizeLevelPath(`/Game/Maps/Imported_${Math.floor(Date.now() / 1000)}`);
 
     try {
-      const res = await this.sendAutomationRequest('manage_level', {
+      const res = await this.sendAutomationRequest<LevelResponse>('manage_level', {
         action: 'import_level',
         packagePath: params.packagePath,
         destinationPath: destination.path
-      }, { timeoutMs: params.timeoutMs ?? 300000 });
+      }, { timeoutMs: params.timeoutMs ?? LONG_RUNNING_OP_TIMEOUT_MS });
 
       if ((res as any)?.success === false) {
         return {
@@ -325,7 +345,7 @@ export class LevelTools extends BaseTool implements ILevelTools {
           error: (res as any).error || (res as any).message || 'Import failed',
           levelPath: destination.path,
           details: res
-        };
+        } as StandardActionResponse;
       }
 
       return {
@@ -335,23 +355,23 @@ export class LevelTools extends BaseTool implements ILevelTools {
         partitioned: true,
         streaming: Boolean(params.streaming),
         details: res
-      };
-    } catch (e: any) {
-      return { success: false, error: `Import failed: ${e.message}` };
+      } as StandardActionResponse;
+    } catch (e: unknown) {
+      return { success: false, error: `Import failed: ${e instanceof Error ? e.message : String(e)}` };
     }
   }
 
-  async saveLevelAs(params: { sourcePath?: string; targetPath: string }) {
+  async saveLevelAs(params: { sourcePath?: string; targetPath: string }): Promise<StandardActionResponse> {
     const source = this.resolveLevelPath(params.sourcePath);
     const target = this.normalizeLevelPath(params.targetPath);
 
     // Delegate to automation bridge
     try {
-      const response = await this.sendAutomationRequest('manage_level', {
+      const response = await this.sendAutomationRequest<LevelResponse>('manage_level', {
         action: 'save_level_as',
         savePath: target.path
       }, {
-        timeoutMs: 60000
+        timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS
       });
 
       if (response.success === false) {
@@ -391,13 +411,13 @@ export class LevelTools extends BaseTool implements ILevelTools {
         success: true,
         message: response.message || `Level saved as ${target.path}`,
         levelPath: target.path
-      };
+      } as StandardActionResponse;
     } catch (error) {
       return { success: false, error: `Failed to save level as: ${error instanceof Error ? error.message : String(error)}` };
     }
   }
 
-  async deleteLevels(params: { levelPaths: string[] }) {
+  async deleteLevels(params: { levelPaths: string[] }): Promise<StandardActionResponse> {
     const removed: string[] = [];
     for (const path of params.levelPaths) {
       const normalized = this.normalizeLevelPath(path).path;
@@ -411,14 +431,14 @@ export class LevelTools extends BaseTool implements ILevelTools {
       success: true,
       message: removed.length ? `Deleted ${removed.length} managed level(s)` : 'No managed levels removed',
       removed
-    };
+    } as StandardActionResponse;
   }
 
   async loadLevel(params: {
     levelPath: string;
     streaming?: boolean;
     position?: [number, number, number];
-  }) {
+  }): Promise<StandardActionResponse> {
     const normalizedPath = this.normalizeLevelPath(params.levelPath).path;
 
     if (params.streaming) {
@@ -435,7 +455,7 @@ export class LevelTools extends BaseTool implements ILevelTools {
           message: `Streaming level loaded: ${params.levelPath}`,
           levelPath: normalizedPath,
           streaming: true
-        };
+        } as StandardActionResponse;
       } catch (err) {
         return {
           success: false,
@@ -446,10 +466,10 @@ export class LevelTools extends BaseTool implements ILevelTools {
     } else {
       // Try loading via automation bridge first (more robust)
       try {
-        const response = await this.sendAutomationRequest('manage_level', {
+        const response = await this.sendAutomationRequest<LevelResponse>('manage_level', {
           action: 'load',
           levelPath: params.levelPath
-        }, { timeoutMs: 30000 });
+        }, { timeoutMs: DEFAULT_OPERATION_TIMEOUT_MS });
 
         if (response.success) {
           this.setCurrentLevel(normalizedPath);
@@ -459,12 +479,12 @@ export class LevelTools extends BaseTool implements ILevelTools {
             visible: true
           });
           return {
+            ...response,
             success: true,
             message: `Level loaded: ${params.levelPath}`,
             level: normalizedPath,
-            streaming: false,
-            ...response
-          };
+            streaming: false
+          } as StandardActionResponse;
         }
       } catch (_e) {
         // Fallback to console logic
@@ -492,7 +512,7 @@ export class LevelTools extends BaseTool implements ILevelTools {
                 error: 'not_found',
                 message,
                 level: normalizedPath
-              };
+              } as StandardActionResponse;
             }
           }
         } catch {
@@ -511,7 +531,7 @@ export class LevelTools extends BaseTool implements ILevelTools {
           message: `Level loaded: ${params.levelPath}`,
           level: normalizedPath,
           streaming: false
-        };
+        } as StandardActionResponse;
       } catch (err) {
         return {
           success: false,
@@ -525,7 +545,7 @@ export class LevelTools extends BaseTool implements ILevelTools {
   async saveLevel(params: {
     levelName?: string;
     savePath?: string;
-  }) {
+  }): Promise<StandardActionResponse> {
     try {
       if (params.savePath && !params.savePath.startsWith('/Game/')) {
         throw new Error(`Invalid save path: ${params.savePath}`);
@@ -537,8 +557,8 @@ export class LevelTools extends BaseTool implements ILevelTools {
         payload.savePath = params.savePath;
       }
 
-      const response = await this.sendAutomationRequest('manage_level', payload, {
-        timeoutMs: 60000
+      const response = await this.sendAutomationRequest<LevelResponse>('manage_level', payload, {
+        timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS
       });
 
       if (response.success === false) {
@@ -546,9 +566,9 @@ export class LevelTools extends BaseTool implements ILevelTools {
       }
 
       const result: Record<string, unknown> = {
+        ...response,
         success: true,
-        message: response.message || 'Level saved',
-        ...response
+        message: response.message || 'Level saved'
       };
 
       if (response.skipped) {
@@ -564,7 +584,7 @@ export class LevelTools extends BaseTool implements ILevelTools {
         result.details = response.details;
       }
 
-      return result;
+      return result as StandardActionResponse;
     } catch (error) {
       return { success: false, error: `Failed to save level: ${error instanceof Error ? error.message : String(error)}` };
     }
@@ -574,17 +594,17 @@ export class LevelTools extends BaseTool implements ILevelTools {
     levelName: string;
     template?: 'Empty' | 'Default' | 'VR' | 'TimeOfDay';
     savePath?: string;
-  }) {
+  }): Promise<StandardActionResponse> {
     const basePath = params.savePath || '/Game/Maps';
     const isPartitioned = true; // default to World Partition for UE5
     const fullPath = `${basePath}/${params.levelName}`;
 
     try {
-      const response = await this.sendAutomationRequest('create_new_level', {
+      const response = await this.sendAutomationRequest<LevelResponse>('create_new_level', {
         levelPath: fullPath,
         useWorldPartition: isPartitioned
       }, {
-        timeoutMs: 60000
+        timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS
       });
 
       if (response.success === false) {
@@ -593,17 +613,17 @@ export class LevelTools extends BaseTool implements ILevelTools {
           error: response.error || response.message || 'Failed to create level',
           path: fullPath,
           partitioned: isPartitioned
-        };
+        } as StandardActionResponse;
       }
 
       const result: Record<string, unknown> = {
+        ...response,
         success: true,
         message: response.message || 'Level created',
         path: response.levelPath || fullPath,
         packagePath: response.packagePath ?? fullPath,
         objectPath: response.objectPath,
-        partitioned: isPartitioned,
-        ...response
+        partitioned: isPartitioned
       };
 
       if (response.warnings) {
@@ -621,14 +641,14 @@ export class LevelTools extends BaseTool implements ILevelTools {
         createdAt: Date.now()
       });
 
-      return result;
+      return result as StandardActionResponse;
     } catch (error) {
       return {
         success: false,
         error: `Failed to create level: ${error instanceof Error ? error.message : String(error)}`,
         path: fullPath,
         partitioned: isPartitioned
-      };
+      } as StandardActionResponse;
     }
   }
 
@@ -636,7 +656,7 @@ export class LevelTools extends BaseTool implements ILevelTools {
     parentLevel?: string;
     subLevelPath: string;
     streamingMethod?: 'Blueprint' | 'AlwaysLoaded';
-  }) {
+  }): Promise<StandardActionResponse> {
     const parent = params.parentLevel ? this.resolveLevelPath(params.parentLevel) : this.currentLevelPath;
     const sub = this.normalizeLevelPath(params.subLevelPath).path;
 
@@ -652,35 +672,35 @@ export class LevelTools extends BaseTool implements ILevelTools {
 
     // Attempt automation first (cleaner)
     try {
-      let response = await this.sendAutomationRequest('manage_level', {
+      let response = await this.sendAutomationRequest<LevelResponse>('manage_level', {
         action: 'add_sublevel',
         levelPath: sub, // Backwards compat
         subLevelPath: sub,
         parentPath: parent,
         streamingMethod: params.streamingMethod
-      }, { timeoutMs: 30000 });
+      }, { timeoutMs: DEFAULT_OPERATION_TIMEOUT_MS });
 
       // Retry with .umap if package not found (Workaround for C++ strictness)
       // Also retry if ADD_FAILED, as UEditorLevelUtils might have failed due to path resolution internally
       if (response && (response.error === 'PACKAGE_NOT_FOUND' || response.error === 'ADD_FAILED') && !sub.endsWith('.umap')) {
         const subWithExt = sub + '.umap';
-        response = await this.sendAutomationRequest('manage_level', {
+        response = await this.sendAutomationRequest<LevelResponse>('manage_level', {
           action: 'add_sublevel',
           levelPath: subWithExt,
           subLevelPath: subWithExt,
           parentPath: parent,
           streamingMethod: params.streamingMethod
-        }, { timeoutMs: 30000 });
+        }, { timeoutMs: DEFAULT_OPERATION_TIMEOUT_MS });
       }
 
       if (response.success) {
         this.ensureRecord(sub, { loaded: true, visible: true, streaming: true });
-        return response;
+        return response as StandardActionResponse;
       } else if (response.error === 'UNKNOWN_ACTION') {
         // Fallthrough to console fallback if action not implemented
       } else {
         // Return actual error if it's something else (e.g. execution failed)
-        return response;
+        return response as StandardActionResponse;
       }
     } catch (_e: any) {
       // If connection failed, might fallback. But if we got a response, respect it.
@@ -688,7 +708,7 @@ export class LevelTools extends BaseTool implements ILevelTools {
 
     // Console fallback
     // Try using LevelEditor.AddLevel command which is available in Editor context
-    const consoleResponse = await this.sendAutomationRequest('console_command', {
+    const consoleResponse = await this.sendAutomationRequest<LevelResponse>('console_command', {
       command: `LevelEditor.AddLevel ${sub}`
     });
 
@@ -698,7 +718,7 @@ export class LevelTools extends BaseTool implements ILevelTools {
         success: true,
         message: `Sublevel added via console: ${sub}`,
         data: { method: 'console' }
-      };
+      } as StandardActionResponse;
     }
 
     return {
@@ -707,7 +727,7 @@ export class LevelTools extends BaseTool implements ILevelTools {
       // Return the last relevant error + console error
       message: 'Failed to add sublevel via automation or console.',
       details: { consoleError: consoleResponse }
-    };
+    } as StandardActionResponse;
   }
 
   async streamLevel(params: {
@@ -716,7 +736,7 @@ export class LevelTools extends BaseTool implements ILevelTools {
     shouldBeLoaded: boolean;
     shouldBeVisible?: boolean;
     position?: [number, number, number];
-  }) {
+  }): Promise<StandardActionResponse> {
     const rawPath = typeof params.levelPath === 'string' ? params.levelPath.trim() : '';
     const levelPath = rawPath.length > 0 ? rawPath : undefined;
     const providedName = typeof params.levelName === 'string' ? params.levelName.trim() : '';
@@ -727,13 +747,13 @@ export class LevelTools extends BaseTool implements ILevelTools {
     const shouldBeVisible = params.shouldBeVisible ?? params.shouldBeLoaded;
 
     try {
-      const response = await this.sendAutomationRequest('stream_level', {
+      const response = await this.sendAutomationRequest<LevelResponse>('stream_level', {
         levelPath: levelPath || '',
         levelName: levelName || '',
         shouldBeLoaded: params.shouldBeLoaded,
         shouldBeVisible
       }, {
-        timeoutMs: 60000
+        timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS
       });
 
       if (response.success === false) {
@@ -758,7 +778,7 @@ export class LevelTools extends BaseTool implements ILevelTools {
             handledResult.details = response.details;
           }
 
-          return handledResult;
+          return handledResult as StandardActionResponse;
         }
 
         return {
@@ -768,7 +788,7 @@ export class LevelTools extends BaseTool implements ILevelTools {
           levelPath: levelPath,
           loaded: params.shouldBeLoaded,
           visible: shouldBeVisible
-        };
+        } as StandardActionResponse;
       }
 
       const result: Record<string, unknown> = {
@@ -787,7 +807,7 @@ export class LevelTools extends BaseTool implements ILevelTools {
         result.details = response.details;
       }
 
-      return result;
+      return result as StandardActionResponse;
     } catch (_error) {
       // Fallback to console command
       const levelIdentifier = levelName ?? levelPath ?? '';
@@ -804,7 +824,7 @@ export class LevelTools extends BaseTool implements ILevelTools {
     tileSize?: number;
     distanceStreaming?: boolean;
     streamingDistance?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     const commands: string[] = [];
 
     if (params.enableComposition) {
@@ -832,7 +852,7 @@ export class LevelTools extends BaseTool implements ILevelTools {
       position: [number, number];
       connections?: string[];
     }>;
-  }) {
+  }): Promise<StandardActionResponse> {
     const command = `OpenLevelBlueprint ${params.eventType}`;
     return this.bridge.executeConsoleCommand(command);
   }
@@ -841,7 +861,7 @@ export class LevelTools extends BaseTool implements ILevelTools {
     name: string;
     type: 'Persistent' | 'Streaming' | 'Lighting' | 'Gameplay';
     parent?: string;
-  }) {
+  }): Promise<StandardActionResponse> {
     const command = `CreateSubLevel ${params.name} ${params.type} ${params.parent || 'None'}`;
     return this.bridge.executeConsoleCommand(command);
   }
@@ -852,7 +872,7 @@ export class LevelTools extends BaseTool implements ILevelTools {
     gameMode?: string;
     defaultPawn?: string;
     killZ?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     const commands: string[] = [];
 
     if (params.gravity !== undefined) {
@@ -879,7 +899,7 @@ export class LevelTools extends BaseTool implements ILevelTools {
   async setLevelBounds(params: {
     min: [number, number, number];
     max: [number, number, number];
-  }) {
+  }): Promise<StandardActionResponse> {
     const command = `SetLevelBounds ${params.min.join(',')} ${params.max.join(',')}`;
     return this.bridge.executeConsoleCommand(command);
   }
@@ -887,9 +907,9 @@ export class LevelTools extends BaseTool implements ILevelTools {
   async buildNavMesh(params: {
     rebuildAll?: boolean;
     selectedOnly?: boolean;
-  }) {
+  }): Promise<StandardActionResponse> {
     try {
-      const response = await this.sendAutomationRequest('build_navigation_mesh', {
+      const response = await this.sendAutomationRequest<LevelResponse>('build_navigation_mesh', {
         rebuildAll: params.rebuildAll ?? false,
         selectedOnly: params.selectedOnly ?? false
       }, {
@@ -924,7 +944,7 @@ export class LevelTools extends BaseTool implements ILevelTools {
         result.details = response.details;
       }
 
-      return result;
+      return result as StandardActionResponse;
     } catch (error) {
       return {
         success: false,
@@ -936,14 +956,14 @@ export class LevelTools extends BaseTool implements ILevelTools {
   async setLevelVisibility(params: {
     levelName: string;
     visible: boolean;
-  }) {
+  }): Promise<StandardActionResponse> {
     const command = `SetLevelVisibility ${params.levelName} ${params.visible}`;
     return this.bridge.executeConsoleCommand(command);
   }
 
   async setWorldOrigin(params: {
     location: [number, number, number];
-  }) {
+  }): Promise<StandardActionResponse> {
     const command = `SetWorldOriginLocation ${params.location.join(' ')}`;
     return this.bridge.executeConsoleCommand(command);
   }
@@ -953,7 +973,7 @@ export class LevelTools extends BaseTool implements ILevelTools {
     position: [number, number, number];
     size: [number, number, number];
     streamingDistance?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     const command = `CreateStreamingVolume ${params.levelName} ${params.position.join(' ')} ${params.size.join(' ')} ${params.streamingDistance || 0}`;
     return this.bridge.executeConsoleCommand(command);
   }
@@ -962,7 +982,7 @@ export class LevelTools extends BaseTool implements ILevelTools {
     levelName: string;
     lodLevel: number;
     distance: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     const command = `SetLevelLOD ${params.levelName} ${params.lodLevel} ${params.distance}`;
     return this.bridge.executeConsoleCommand(command);
   }