unreal-engine-mcp-server 0.5.0 → 0.5.2

package/dist/tools/actors.d.ts

@@ -22,7 +22,7 @@ export declare class ActorTools extends BaseTool implements IActorTools {
     delete(params: {
         actorName?: string;
         actorNames?: string[];
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     applyForce(params: {
         actorName: string;
         force: {
@@ -30,7 +30,7 @@ export declare class ActorTools extends BaseTool implements IActorTools {
             y: number;
             z: number;
         };
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     private resolveActorClass;
     spawnBlueprint(params: {
         blueprintPath: string;
@@ -45,7 +45,7 @@ export declare class ActorTools extends BaseTool implements IActorTools {
             yaw: number;
             roll: number;
         };
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     setTransform(params: {
         actorName: string;
         location?: {
@@ -63,26 +63,48 @@ export declare class ActorTools extends BaseTool implements IActorTools {
             y: number;
             z: number;
         };
-    }): Promise<any>;
-    getTransform(actorName: string): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
+    getTransform(actorName: string): Promise<{
+        success: boolean;
+        error: string | {
+            [key: string]: unknown;
+            code?: string;
+            message: string;
+        };
+        message?: undefined;
+        location?: undefined;
+        rotation?: undefined;
+        scale?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        location: any;
+        rotation: any;
+        scale: any;
+        error?: undefined;
+    }>;
     setVisibility(params: {
         actorName: string;
         visible: boolean;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     addComponent(params: {
         actorName: string;
         componentType: string;
         componentName?: string;
         properties?: Record<string, unknown>;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     setComponentProperties(params: {
         actorName: string;
         componentName: string;
         properties: Record<string, unknown>;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     getComponents(actorName: string): Promise<{
         success: boolean;
-        error: any;
+        error: string | {
+            [key: string]: unknown;
+            code?: string;
+            message: string;
+        };
         message?: undefined;
         components?: undefined;
         count?: undefined;
@@ -101,45 +123,49 @@ export declare class ActorTools extends BaseTool implements IActorTools {
             y: number;
             z: number;
         };
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     addTag(params: {
         actorName: string;
         tag: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     removeTag(params: {
         actorName: string;
         tag: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     findByTag(params: {
         tag: string;
         matchType?: string;
-    }): Promise<any>;
-    findByName(name: string): Promise<any>;
-    detach(actorName: string): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
+    findByName(name: string): Promise<StandardActionResponse<any>>;
+    detach(actorName: string): Promise<StandardActionResponse<any>>;
     attach(params: {
         childActor: string;
         parentActor: string;
-    }): Promise<any>;
-    deleteByTag(tag: string): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
+    deleteByTag(tag: string): Promise<StandardActionResponse<any>>;
     setBlueprintVariables(params: {
         actorName: string;
         variables: Record<string, unknown>;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     createSnapshot(params: {
         actorName: string;
         snapshotName: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     restoreSnapshot(params: {
         actorName: string;
         snapshotName: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     exportActor(params: {
         actorName: string;
         destinationPath?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     getBoundingBox(actorName: string): Promise<{
         success: boolean;
-        error: any;
+        error: string | {
+            [key: string]: unknown;
+            code?: string;
+            message: string;
+        };
         message?: undefined;
         boundingBox?: undefined;
     } | {
@@ -150,7 +176,11 @@ export declare class ActorTools extends BaseTool implements IActorTools {
     }>;
     getMetadata(actorName: string): Promise<{
         success: boolean;
-        error: any;
+        error: string | {
+            [key: string]: unknown;
+            code?: string;
+            message: string;
+        };
         message?: undefined;
         metadata?: undefined;
     } | {
@@ -163,7 +193,11 @@ export declare class ActorTools extends BaseTool implements IActorTools {
         filter?: string;
     }): Promise<{
         success: boolean;
-        error: any;
+        error: string | {
+            [key: string]: unknown;
+            code?: string;
+            message: string;
+        };
         message?: undefined;
         actors?: undefined;
         count?: undefined;

package/dist/tools/actors.js

@@ -1,5 +1,6 @@
 import { ensureRotation, ensureVector3 } from '../utils/validation.js';
 import { BaseTool } from './base-tool.js';
+import { wasmIntegration } from '../wasm/index.js';
 export class ActorTools extends BaseTool {
     constructor(bridge) {
         super(bridge);
@@ -38,7 +39,10 @@ export class ActorTools extends BaseTool {
                 meshPath: params.meshPath
             }, timeoutMs ? { timeoutMs } : undefined);
             if (!response || !response.success) {
-                throw new Error(response?.error || response?.message || 'Failed to spawn actor');
+                const error = response?.error;
+                const errorObj = typeof error === 'object' && error !== null ? error : null;
+                const errorMsg = typeof error === 'string' ? error : errorObj?.message || response?.message || 'Failed to spawn actor';
+                throw new Error(errorMsg);
             }
             const data = response.data || {};
             const result = {
@@ -223,10 +227,19 @@ export class ActorTools extends BaseTool {
         if (typeof actorName !== 'string' || actorName.trim().length === 0) {
             throw new Error('Invalid actorName');
         }
-        return this.sendRequest('get_transform', { actorName }, 'control_actor')
-            .then(response => {
-            return response;
-        });
+        const response = await this.sendRequest('get_transform', { actorName }, 'control_actor');
+        if (!response.success) {
+            return { success: false, error: response.error || `Failed to get transform for actor ${actorName}` };
+        }
+        const rawData = response.data ?? response.result ?? response;
+        const data = rawData?.data ?? rawData;
+        return {
+            success: true,
+            message: 'Transform retrieved',
+            location: data.location ?? data.Location,
+            rotation: data.rotation ?? data.Rotation,
+            scale: data.scale ?? data.Scale
+        };
     }
     async setVisibility(params) {
         const actorName = typeof params.actorName === 'string' ? params.actorName.trim() : '';
@@ -292,7 +305,10 @@ export class ActorTools extends BaseTool {
         }
         if (params.offset) {
             const offs = ensureVector3(params.offset, 'duplicate offset');
-            payload.offset = { x: offs[0], y: offs[1], z: offs[2] };
+            const origin = [0, 0, 0];
+            const calculatedOffset = wasmIntegration.vectorAdd(origin, offs);
+            console.error('[WASM] Using vectorAdd for duplicate offset calculation');
+            payload.offset = { x: calculatedOffset[0], y: calculatedOffset[1], z: calculatedOffset[2] };
         }
         return this.sendRequest('duplicate', payload, 'control_actor');
     }

package/dist/tools/assets.d.ts

@@ -1,5 +1,5 @@
 import { BaseTool } from './base-tool.js';
-import { IAssetTools } from '../types/tool-interfaces.js';
+import { IAssetTools, StandardActionResponse, SourceControlState } from '../types/tool-interfaces.js';
 export declare class AssetTools extends BaseTool implements IAssetTools {
     private normalizeAssetPath;
     importAsset(params: {
@@ -7,124 +7,72 @@ export declare class AssetTools extends BaseTool implements IAssetTools {
         destinationPath: string;
         overwrite?: boolean;
         save?: boolean;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     duplicateAsset(params: {
         sourcePath: string;
         destinationPath: string;
         overwrite?: boolean;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     renameAsset(params: {
         sourcePath: string;
         destinationPath: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     moveAsset(params: {
         sourcePath: string;
         destinationPath: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     findByTag(params: {
         tag: string;
         value?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     deleteAssets(params: {
         paths: string[];
         fixupRedirectors?: boolean;
         timeoutMs?: number;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     searchAssets(params: {
         classNames?: string[];
         packagePaths?: string[];
         recursivePaths?: boolean;
         recursiveClasses?: boolean;
         limit?: number;
-    }): Promise<{
-        success: boolean;
-        error: any;
-        message?: undefined;
-        assets?: undefined;
-        count?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        assets: any[];
-        count: number;
-        error?: undefined;
-    }>;
-    saveAsset(assetPath: string): Promise<any>;
-    createFolder(folderPath: string): Promise<any>;
+    }): Promise<StandardActionResponse>;
+    saveAsset(assetPath: string): Promise<StandardActionResponse>;
+    createFolder(folderPath: string): Promise<StandardActionResponse>;
     getDependencies(params: {
         assetPath: string;
         recursive?: boolean;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     getSourceControlState(params: {
         assetPath: string;
-    }): Promise<any>;
+    }): Promise<SourceControlState | StandardActionResponse>;
     getMetadata(params: {
         assetPath: string;
-    }): Promise<{
-        success: boolean;
-        message: string;
-    }>;
+    }): Promise<StandardActionResponse>;
     analyzeGraph(params: {
         assetPath: string;
         maxDepth?: number;
-    }): Promise<{
-        success: boolean;
-        error: any;
-        message?: undefined;
-        analysis?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        analysis: {
-            asset: any;
-            dependencies: any[];
-            totalDependencyCount: any;
-            requestedMaxDepth: number;
-            maxDepthUsed: number;
-            circularDependencies: string[][];
-            topologicalOrder: string[];
-            stats: {
-                nodeCount: number;
-                leafCount: number;
-            };
-        };
-        error?: undefined;
-    }>;
+    }): Promise<StandardActionResponse>;
     createThumbnail(params: {
         assetPath: string;
         width?: number;
         height?: number;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     setTags(params: {
         assetPath: string;
         tags: string[];
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     generateReport(params: {
         directory: string;
         reportType?: string;
         outputPath?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     validate(params: {
         assetPath: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     generateLODs(params: {
         assetPath: string;
         lodCount: number;
-    }): Promise<{
-        success: boolean;
-        error: string;
-        details?: undefined;
-    } | {
-        success: boolean;
-        error: any;
-        details: any;
-    } | {
-        success: boolean;
-        message: any;
-        assetPath: string;
-        lodCount: number;
-        error?: undefined;
-        details?: undefined;
-    }>;
+    }): Promise<StandardActionResponse>;
 }
 //# sourceMappingURL=assets.d.ts.map

package/dist/tools/assets.js

@@ -1,5 +1,9 @@
 import { BaseTool } from './base-tool.js';
 import { wasmIntegration } from '../wasm/index.js';
+import { Logger } from '../utils/logger.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 {
     normalizeAssetPath(path) {
         if (!path)
@@ -15,13 +19,14 @@ export class AssetTools extends BaseTool {
             else
                 normalized = '/Game/' + normalized;
         }
-        return normalized.replace(/\/+/g, '/');
+        normalized = normalized.replace(/\/+/g, '/');
+        return sanitizePath(normalized);
     }
     async importAsset(params) {
         const res = await this.sendRequest('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 };
         }
@@ -35,7 +40,7 @@ export class AssetTools extends BaseTool {
             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 };
         }
@@ -48,7 +53,7 @@ export class AssetTools extends BaseTool {
             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 };
         }
@@ -61,7 +66,7 @@ export class AssetTools extends BaseTool {
             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 };
         }
@@ -71,7 +76,7 @@ export class AssetTools extends BaseTool {
         return this.sendRequest('asset_query', {
             ...params,
             subAction: 'find_by_tag'
-        }, 'asset_query', { timeoutMs: 60000 });
+        }, 'asset_query', { timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS });
     }
     async deleteAssets(params) {
         const assetPaths = (Array.isArray(params.paths) ? params.paths : [])
@@ -80,7 +85,7 @@ export class AssetTools extends BaseTool {
             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) {
         const packagePaths = params.packagePaths
@@ -90,10 +95,10 @@ export class AssetTools extends BaseTool {
             ...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;
         const assets = Array.isArray(assetsRaw) ? assetsRaw : [];
@@ -110,7 +115,7 @@ export class AssetTools extends BaseTool {
             const bridge = this.getAutomationBridge();
             if (bridge && typeof bridge.sendAutomationRequest === 'function') {
                 try {
-                    const response = await bridge.sendAutomationRequest('manage_asset', { assetPath: normalizedPath, subAction: 'save_asset' }, { timeoutMs: 60000 });
+                    const response = await bridge.sendAutomationRequest('manage_asset', { assetPath: normalizedPath, subAction: 'save_asset' }, { timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS });
                     if (response && response.success !== false) {
                         return {
                             success: true,
@@ -120,7 +125,8 @@ export class AssetTools extends BaseTool {
                         };
                     }
                 }
-                catch (_err) {
+                catch (primaryError) {
+                    log.debug('saveAsset primary method failed, trying fallback', primaryError);
                 }
             }
             const res = await this.bridge.executeEditorFunction('SAVE_ASSET', { path: normalizedPath });
@@ -131,7 +137,7 @@ export class AssetTools extends BaseTool {
             return { success: false, error: res?.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) {
@@ -139,7 +145,7 @@ export class AssetTools extends BaseTool {
         return this.sendRequest('manage_asset', {
             path,
             subAction: 'create_folder'
-        }, 'manage_asset', { timeoutMs: 60000 });
+        }, 'manage_asset', { timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS });
     }
     async getDependencies(params) {
         return this.sendRequest('manage_asset', {
@@ -176,7 +182,7 @@ export class AssetTools extends BaseTool {
                 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' };
             }
@@ -216,7 +222,7 @@ export class AssetTools extends BaseTool {
             };
         }
         catch (e) {
-            return { success: false, error: `Analysis failed: ${e.message}` };
+            return { success: false, error: `Analysis failed: ${e instanceof Error ? e.message : String(e)} ` };
         }
     }
     async createThumbnail(params) {
@@ -224,28 +230,28 @@ export class AssetTools extends BaseTool {
             ...params,
             assetPath: this.normalizeAssetPath(params.assetPath),
             subAction: 'generate_thumbnail'
-        }, 'manage_asset', { timeoutMs: 60000 });
+        }, 'manage_asset', { timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS });
     }
     async setTags(params) {
         return this.sendRequest('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) {
         return this.sendRequest('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) {
         return this.sendRequest('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) {
         const assetPath = this.normalizeAssetPath(String(params.assetPath ?? '').trim());
@@ -263,7 +269,7 @@ export class AssetTools extends BaseTool {
                 assetPaths: [assetPath],
                 numLODs: lodCount,
                 subAction: 'generate_lods'
-            }, { timeoutMs: 120000 });
+            }, { timeoutMs: EXTENDED_ASSET_OP_TIMEOUT_MS });
             if (!response || response.success === false) {
                 return {
                     success: false,
@@ -283,7 +289,7 @@ export class AssetTools extends BaseTool {
         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/dist/tools/base-tool.d.ts

@@ -5,13 +5,13 @@ export declare abstract class BaseTool implements IBaseTool {
     protected bridge: UnrealBridge;
     constructor(bridge: UnrealBridge);
     getAutomationBridge(): AutomationBridge;
-    protected sendRequest(action: string, params: Record<string, unknown>, toolName?: string, options?: {
+    protected sendRequest<T = unknown>(action: string, params: Record<string, unknown>, toolName?: string, options?: {
         timeoutMs?: number;
-    }): Promise<any>;
-    protected sendAutomationRequest(action: string, params?: Record<string, unknown>, options?: {
+    }): Promise<T>;
+    protected sendAutomationRequest<T = unknown>(action: string, params?: Record<string, unknown>, options?: {
         timeoutMs?: number;
         waitForEvent?: boolean;
         waitForEventTimeoutMs?: number;
-    }): Promise<any>;
+    }): Promise<T>;
 }
 //# sourceMappingURL=base-tool.d.ts.map

package/dist/tools/base-tool.js

@@ -33,7 +33,7 @@ export class BaseTool {
             }
             throw new Error(errorMessage);
         }
-        return response.result ?? response;
+        return (response.result ?? response);
     }
     async sendAutomationRequest(action, params = {}, options) {
         const automation = this.getAutomationBridge();