unreal-engine-mcp-server 0.5.0 → 0.5.1

package/src/tools/assets.ts

@@ -1,7 +1,16 @@
-
 import { BaseTool } from './base-tool.js';
-import { IAssetTools } from '../types/tool-interfaces.js';
+import { IAssetTools, StandardActionResponse, SourceControlState } from '../types/tool-interfaces.js';
 import { wasmIntegration } from '../wasm/index.js';
+import { Logger } from '../utils/logger.js';
+import { AssetResponse } from '../types/automation-responses.js';
+import { sanitizePath } from '../utils/path-security.js';
+import {
+  DEFAULT_ASSET_OP_TIMEOUT_MS,
+  EXTENDED_ASSET_OP_TIMEOUT_MS,
+  LONG_RUNNING_OP_TIMEOUT_MS
+} from '../constants.js';
+
+const log = new Logger('AssetTools');
 
 export class AssetTools extends BaseTool implements IAssetTools {
   private normalizeAssetPath(path: string): string {
@@ -18,106 +27,105 @@ export class AssetTools extends BaseTool implements IAssetTools {
     }
 
     // Remove double slashes just in case
-    return normalized.replace(/\/+/g, '/');
+    normalized = normalized.replace(/\/+/g, '/');
+
+    // Security check
+    return sanitizePath(normalized);
   }
 
-  async importAsset(params: { sourcePath: string; destinationPath: string; overwrite?: boolean; save?: boolean }) {
-    const res = await this.sendRequest('manage_asset', {
+  async importAsset(params: { sourcePath: string; destinationPath: string; overwrite?: boolean; save?: boolean }): Promise<StandardActionResponse> {
+    const res = await this.sendRequest<AssetResponse>('manage_asset', {
       ...params,
       subAction: 'import'
-    }, 'manage_asset', { timeoutMs: 120000 });
+    }, 'manage_asset', { timeoutMs: EXTENDED_ASSET_OP_TIMEOUT_MS });
     if (res && res.success) {
       return { ...res, asset: this.normalizeAssetPath(params.destinationPath), source: params.sourcePath };
     }
     return res;
   }
 
-  async duplicateAsset(params: { sourcePath: string; destinationPath: string; overwrite?: boolean }) {
+  async duplicateAsset(params: { sourcePath: string; destinationPath: string; overwrite?: boolean }): Promise<StandardActionResponse> {
     const sourcePath = this.normalizeAssetPath(params.sourcePath);
     const destinationPath = this.normalizeAssetPath(params.destinationPath);
 
-    const res = await this.sendRequest('manage_asset', {
+    const res = await this.sendRequest<AssetResponse>('manage_asset', {
       sourcePath,
       destinationPath,
       overwrite: params.overwrite ?? false,
       subAction: 'duplicate'
-    }, 'manage_asset', { timeoutMs: 60000 });
+    }, 'manage_asset', { timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS });
     if (res && res.success) {
       return { ...res, asset: destinationPath, source: sourcePath };
     }
     return res;
   }
 
-  async renameAsset(params: { sourcePath: string; destinationPath: string }) {
+  async renameAsset(params: { sourcePath: string; destinationPath: string }): Promise<StandardActionResponse> {
     const sourcePath = this.normalizeAssetPath(params.sourcePath);
     const destinationPath = this.normalizeAssetPath(params.destinationPath);
 
-    const res = await this.sendRequest('manage_asset', {
+    const res = await this.sendRequest<AssetResponse>('manage_asset', {
       sourcePath,
       destinationPath,
       subAction: 'rename'
-    }, 'manage_asset', { timeoutMs: 60000 });
+    }, 'manage_asset', { timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS });
     if (res && res.success) {
       return { ...res, asset: destinationPath, oldName: sourcePath };
     }
     return res;
   }
 
-  async moveAsset(params: { sourcePath: string; destinationPath: string }) {
+  async moveAsset(params: { sourcePath: string; destinationPath: string }): Promise<StandardActionResponse> {
     const sourcePath = this.normalizeAssetPath(params.sourcePath);
     const destinationPath = this.normalizeAssetPath(params.destinationPath);
 
-    const res = await this.sendRequest('manage_asset', {
+    const res = await this.sendRequest<AssetResponse>('manage_asset', {
       sourcePath,
       destinationPath,
       subAction: 'move'
-    }, 'manage_asset', { timeoutMs: 60000 });
+    }, 'manage_asset', { timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS });
     if (res && res.success) {
       return { ...res, asset: destinationPath, from: sourcePath };
     }
     return res;
   }
 
-  async findByTag(params: { tag: string; value?: string }) {
+  async findByTag(params: { tag: string; value?: string }): Promise<StandardActionResponse> {
     // tag searches don't usually involve paths, but if they did we'd normalize.
     // preserving existing logic for findByTag as it takes 'tag' and 'value'.
-    return this.sendRequest('asset_query', {
+    return this.sendRequest<AssetResponse>('asset_query', {
       ...params,
       subAction: 'find_by_tag'
-    }, 'asset_query', { timeoutMs: 60000 });
+    }, 'asset_query', { timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS });
   }
 
-  async deleteAssets(params: { paths: string[]; fixupRedirectors?: boolean; timeoutMs?: number }) {
+  async deleteAssets(params: { paths: string[]; fixupRedirectors?: boolean; timeoutMs?: number }): Promise<StandardActionResponse> {
     const assetPaths = (Array.isArray(params.paths) ? params.paths : [])
       .map(p => this.normalizeAssetPath(p));
 
-    // Bulk delete maps to 'manage_asset' subAction 'bulk_delete' or 'delete'
-    // C++ 'HandleDeleteAssets' handles single delete, 'HandleBulkDeleteAssets' handles bulk.
-    // Let's use 'bulk_delete' if we have multiple, or 'delete' for consistency?
-    // C++ HandleAssetAction dispatches 'bulk_delete' to HandleBulkDeleteAssets.
-    return this.sendRequest('manage_asset', {
+    return this.sendRequest<AssetResponse>('manage_asset', {
       assetPaths,
       fixupRedirectors: params.fixupRedirectors,
       subAction: 'delete'
-    }, 'manage_asset', { timeoutMs: params.timeoutMs || 120000 });
+    }, 'manage_asset', { timeoutMs: params.timeoutMs || EXTENDED_ASSET_OP_TIMEOUT_MS });
   }
 
-  async searchAssets(params: { classNames?: string[]; packagePaths?: string[]; recursivePaths?: boolean; recursiveClasses?: boolean; limit?: number }) {
+  async searchAssets(params: { classNames?: string[]; packagePaths?: string[]; recursivePaths?: boolean; recursiveClasses?: boolean; limit?: number }): Promise<StandardActionResponse> {
     // Normalize package paths if provided
     const packagePaths = params.packagePaths
       ? params.packagePaths.map(p => this.normalizeAssetPath(p))
       : ['/Game'];
 
     // Route via asset_query action with subAction 'search_assets'
-    const response = await this.sendRequest('asset_query', {
+    const response = await this.sendRequest<AssetResponse>('asset_query', {
       ...params,
       packagePaths,
       subAction: 'search_assets'
-    }, 'asset_query', { timeoutMs: 60000 });
+    }, 'asset_query', { timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS });
 
     if (!response.success) {
-      const errorMsg = response.error || `Failed to search assets. Raw response: ${JSON.stringify(response)}`;
-      return { success: false, error: errorMsg };
+      const errorMsg = typeof response.error === 'string' ? response.error : JSON.stringify(response.error);
+      return { success: false, error: errorMsg || 'Failed to search assets' };
     }
 
     const assetsRaw = response.assets || response.data || response.result;
@@ -131,7 +139,7 @@ export class AssetTools extends BaseTool implements IAssetTools {
     };
   }
 
-  async saveAsset(assetPath: string) {
+  async saveAsset(assetPath: string): Promise<StandardActionResponse> {
     const normalizedPath = this.normalizeAssetPath(assetPath);
     try {
       // Try Automation Bridge first
@@ -149,7 +157,7 @@ export class AssetTools extends BaseTool implements IAssetTools {
             // Let's stick to the existing fallback logic but maybe fix the command if known?
             // Since 'save_asset' is not in Subsystem.cpp, it fails.
             // Let's rely on executeEditorFunction below.
-            { timeoutMs: 60000 }
+            { timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS }
           );
 
           if (response && response.success !== false) {
@@ -160,8 +168,11 @@ export class AssetTools extends BaseTool implements IAssetTools {
               ...response
             };
           }
-        } catch (_err) {
-          // Fall through to executeEditorFunction
+        } catch (primaryError) {
+          // Log the primary method failure before trying fallback
+          // This helps debugging when both methods fail
+          log.debug('saveAsset primary method failed, trying fallback', primaryError);
+          // Fall through to executeEditorFunction fallback
         }
       }
 
@@ -174,43 +185,43 @@ export class AssetTools extends BaseTool implements IAssetTools {
 
       return { success: false, error: (res as any)?.error ?? 'Failed to save asset' };
     } catch (err) {
-      return { success: false, error: `Failed to save asset: ${err}` };
+      return { success: false, error: `Failed to save asset: ${err} ` };
     }
   }
 
-  async createFolder(folderPath: string) {
+  async createFolder(folderPath: string): Promise<StandardActionResponse> {
     // Folders are paths too
     const path = this.normalizeAssetPath(folderPath);
-    return this.sendRequest('manage_asset', {
+    return this.sendRequest<AssetResponse>('manage_asset', {
       path,
       subAction: 'create_folder'
-    }, 'manage_asset', { timeoutMs: 60000 });
+    }, 'manage_asset', { timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS });
   }
 
-  async getDependencies(params: { assetPath: string; recursive?: boolean }) {
+  async getDependencies(params: { assetPath: string; recursive?: boolean }): Promise<StandardActionResponse> {
     // get_dependencies is typically an asset query or managed asset action?
     // HandleAssetAction has 'get_dependencies' dispatch.
-    return this.sendRequest('manage_asset', {
+    return this.sendRequest<AssetResponse>('manage_asset', {
       ...params,
       assetPath: this.normalizeAssetPath(params.assetPath),
       subAction: 'get_dependencies'
     }, 'manage_asset');
   }
 
-  async getSourceControlState(params: { assetPath: string }) {
+  async getSourceControlState(params: { assetPath: string }): Promise<SourceControlState | StandardActionResponse> {
     // Source control state usually via 'asset_query' or 'manage_asset'?
     // It's not in HandleAssetAction explicitly, maybe 'asset_query' subAction?
     // Let's check AssetQueryHandlers.cpp or AssetWorkflowHandlers.cpp dispatch.
     // Assuming 'asset_query' supports it (original code used asset_query).
-    return this.sendRequest('asset_query', {
+    return this.sendRequest<AssetResponse>('asset_query', {
       ...params,
       assetPath: this.normalizeAssetPath(params.assetPath),
       subAction: 'get_source_control_state'
     }, 'asset_query');
   }
 
-  async getMetadata(params: { assetPath: string }) {
-    const response = await this.sendRequest('manage_asset', {
+  async getMetadata(params: { assetPath: string }): Promise<StandardActionResponse> {
+    const response = await this.sendRequest<AssetResponse>('manage_asset', {
       ...params,
       assetPath: this.normalizeAssetPath(params.assetPath),
       subAction: 'get_metadata'
@@ -227,17 +238,17 @@ export class AssetTools extends BaseTool implements IAssetTools {
     };
   }
 
-  async analyzeGraph(params: { assetPath: string; maxDepth?: number }) {
+  async analyzeGraph(params: { assetPath: string; maxDepth?: number }): Promise<StandardActionResponse> {
     const maxDepth = params.maxDepth ?? 3;
     const assetPath = this.normalizeAssetPath(params.assetPath);
 
     try {
       // Offload the heavy graph traversal to C++
-      const response: any = await this.sendRequest('manage_asset', {
+      const response: any = await this.sendRequest<AssetResponse>('manage_asset', {
         assetPath,
         maxDepth,
         subAction: 'get_asset_graph'
-      }, 'manage_asset', { timeoutMs: 60000 });
+      }, 'manage_asset', { timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS });
 
       if (!response.success || !response.graph) {
         return { success: false, error: response.error || 'Failed to retrieve asset graph from engine' };
@@ -300,43 +311,43 @@ export class AssetTools extends BaseTool implements IAssetTools {
         analysis
       };
     } catch (e: any) {
-      return { success: false, error: `Analysis failed: ${e.message}` };
+      return { success: false, error: `Analysis failed: ${e.message} ` };
     }
   }
 
-  async createThumbnail(params: { assetPath: string; width?: number; height?: number }) {
-    return this.sendRequest('manage_asset', {
+  async createThumbnail(params: { assetPath: string; width?: number; height?: number }): Promise<StandardActionResponse> {
+    return this.sendRequest<AssetResponse>('manage_asset', {
       ...params,
       assetPath: this.normalizeAssetPath(params.assetPath),
       subAction: 'generate_thumbnail'
-    }, 'manage_asset', { timeoutMs: 60000 });
+    }, 'manage_asset', { timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS });
   }
 
-  async setTags(params: { assetPath: string; tags: string[] }) {
-    return this.sendRequest('manage_asset', {
+  async setTags(params: { assetPath: string; tags: string[] }): Promise<StandardActionResponse> {
+    return this.sendRequest<AssetResponse>('manage_asset', {
       ...params,
       assetPath: this.normalizeAssetPath(params.assetPath),
       subAction: 'set_tags'
-    }, 'manage_asset', { timeoutMs: 60000 });
+    }, 'manage_asset', { timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS });
   }
 
-  async generateReport(params: { directory: string; reportType?: string; outputPath?: string }) {
-    return this.sendRequest('manage_asset', {
+  async generateReport(params: { directory: string; reportType?: string; outputPath?: string }): Promise<StandardActionResponse> {
+    return this.sendRequest<AssetResponse>('manage_asset', {
       ...params,
       directory: this.normalizeAssetPath(params.directory),
       subAction: 'generate_report'
-    }, 'manage_asset', { timeoutMs: 300000 });
+    }, 'manage_asset', { timeoutMs: LONG_RUNNING_OP_TIMEOUT_MS });
   }
 
-  async validate(params: { assetPath: string }) {
-    return this.sendRequest('manage_asset', {
+  async validate(params: { assetPath: string }): Promise<StandardActionResponse> {
+    return this.sendRequest<AssetResponse>('manage_asset', {
       ...params,
       assetPath: this.normalizeAssetPath(params.assetPath),
       subAction: 'validate'
-    }, 'manage_asset', { timeoutMs: 300000 });
+    }, 'manage_asset', { timeoutMs: LONG_RUNNING_OP_TIMEOUT_MS });
   }
 
-  async generateLODs(params: { assetPath: string; lodCount: number }) {
+  async generateLODs(params: { assetPath: string; lodCount: number }): Promise<StandardActionResponse> {
     const assetPath = this.normalizeAssetPath(String(params.assetPath ?? '').trim());
     const lodCountRaw = Number(params.lodCount);
 
@@ -354,7 +365,7 @@ export class AssetTools extends BaseTool implements IAssetTools {
         assetPaths: [assetPath],
         numLODs: lodCount,
         subAction: 'generate_lods'
-      }, { timeoutMs: 120000 });
+      }, { timeoutMs: EXTENDED_ASSET_OP_TIMEOUT_MS });
 
       if (!response || response.success === false) {
         return {
@@ -376,7 +387,7 @@ export class AssetTools extends BaseTool implements IAssetTools {
     } catch (error) {
       return {
         success: false,
-        error: `Failed to generate LODs: ${error instanceof Error ? error.message : String(error)}`
+        error: `Failed to generate LODs: ${error instanceof Error ? error.message : String(error)} `
       };
     }
   }

package/src/tools/base-tool.ts

@@ -9,7 +9,7 @@ export abstract class BaseTool implements IBaseTool {
         return this.bridge.getAutomationBridge();
     }
 
-    protected async sendRequest(action: string, params: Record<string, unknown>, toolName: string = 'unknown_tool', options?: { timeoutMs?: number }): Promise<any> {
+    protected async sendRequest<T = unknown>(action: string, params: Record<string, unknown>, toolName: string = 'unknown_tool', options?: { timeoutMs?: number }): Promise<T> {
         const automation = this.getAutomationBridge();
 
         // Basic validation
@@ -39,10 +39,10 @@ export abstract class BaseTool implements IBaseTool {
             throw new Error(errorMessage);
         }
 
-        return response.result ?? response;
+        return (response.result ?? response) as T;
     }
 
-    protected async sendAutomationRequest(action: string, params: Record<string, unknown> = {}, options?: { timeoutMs?: number; waitForEvent?: boolean; waitForEventTimeoutMs?: number }): Promise<any> {
+    protected async sendAutomationRequest<T = unknown>(action: string, params: Record<string, unknown> = {}, options?: { timeoutMs?: number; waitForEvent?: boolean; waitForEventTimeoutMs?: number }): Promise<T> {
         const automation = this.getAutomationBridge();
         if (!automation.isConnected()) {
             throw new Error('Automation bridge not connected');