unreal-engine-mcp-server 0.3.1 → 0.4.3

package/dist/tools/assets.d.ts

@@ -5,13 +5,24 @@ export declare class AssetTools {
     importAsset(sourcePath: string, destinationPath: string): Promise<{
         success: boolean;
         message: string;
-        paths: any;
+        imported: number;
+        paths: string[];
         error?: undefined;
+        details?: undefined;
     } | {
+        success: boolean;
+        message: string;
+        error: string;
+        details: string | undefined;
+        imported?: undefined;
+        paths?: undefined;
+    } | {
+        success: boolean;
         error: string;
-        success?: undefined;
         message?: undefined;
+        imported?: undefined;
         paths?: undefined;
+        details?: undefined;
     }>;
     duplicateAsset(sourcePath: string, destinationPath: string): Promise<any>;
     deleteAsset(assetPath: string): Promise<any>;

package/dist/tools/assets.js

@@ -1,19 +1,26 @@
-import * as fs from 'fs';
-import * as path from 'path';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { bestEffortInterpretedText, coerceNumber, coerceStringArray, interpretStandardResult } from '../utils/result-helpers.js';
 export class AssetTools {
     bridge;
     constructor(bridge) {
         this.bridge = bridge;
     }
     async importAsset(sourcePath, destinationPath) {
+        let createdTestFile = false;
         try {
-            // Sanitize destination path (remove trailing slash)
-            const cleanDest = destinationPath.replace(/\/$/, '');
+            // Sanitize destination path (remove trailing slash) and normalize UE path
+            let cleanDest = destinationPath.replace(/\/$/, '');
+            // Map /Content -> /Game for UE asset destinations
+            if (/^\/?content(\/|$)/i.test(cleanDest)) {
+                cleanDest = '/Game' + cleanDest.replace(/^\/?content/i, '');
+            }
             // Create test FBX file if it's a test file
             if (sourcePath.includes('test_model.fbx')) {
                 // Create the file outside of Python, before import
                 try {
-                    this.createTestFBX(sourcePath);
+                    await this.createTestFBX(sourcePath);
+                    createdTestFile = true;
                 }
                 catch (_err) {
                     // If we can't create the file, we'll handle it in Python
@@ -23,6 +30,7 @@ export class AssetTools {
             const pythonCode = `
 import unreal
 import os
+import json
 
 # Create test FBX if needed
 source_path = r'${sourcePath}'
@@ -143,54 +151,57 @@ task.options = options
 
 # Use AssetTools to import
 asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
+result = {'success': False, 'error': 'No assets imported', 'source': task.filename}
+
 try:
     asset_tools.import_asset_tasks([task])
     if task.imported_object_paths:
-        print(f"RESULT:{'{'}'success': True, 'imported': {len(task.imported_object_paths)}, 'paths': {task.imported_object_paths}{'}'}")
-    else:
-        print(f"RESULT:{'{'}'success': False, 'error': 'No assets imported', 'source': task.filename{'}'}")
+        result = {
+            'success': True,
+            'imported': len(task.imported_object_paths),
+            'paths': list(task.imported_object_paths)
+        }
 except Exception as e:
-    print(f"RESULT:{'{'}'success': False, 'error': str(e), 'source': task.filename{'}'}")
+    result = {'success': False, 'error': str(e), 'source': task.filename}
+
+print('RESULT:' + json.dumps(result))
 `.trim();
             const pyResp = await this.bridge.executePython(pythonCode);
-            // Parse Python output
-            let outputStr = '';
-            if (typeof pyResp === 'object' && pyResp !== null) {
-                if (pyResp.LogOutput && Array.isArray(pyResp.LogOutput)) {
-                    outputStr = pyResp.LogOutput.map((l) => l.Output || '').join('');
-                }
-                else if ('ReturnValue' in pyResp) {
-                    outputStr = String(pyResp.ReturnValue);
-                }
-                else {
-                    outputStr = JSON.stringify(pyResp);
-                }
-            }
-            else {
-                outputStr = String(pyResp || '');
+            const interpreted = interpretStandardResult(pyResp, {
+                successMessage: `Imported assets to ${cleanDest}`,
+                failureMessage: 'Import failed'
+            });
+            if (interpreted.success) {
+                const count = coerceNumber(interpreted.payload.imported) ?? 0;
+                const paths = coerceStringArray(interpreted.payload.paths) ?? [];
+                return {
+                    success: true,
+                    message: `Imported ${count} assets to ${cleanDest}`,
+                    imported: count,
+                    paths
+                };
             }
-            const match = outputStr.match(/RESULT:({.*})/);
-            if (match) {
+            const errorMessage = `Import failed: ${interpreted.error ?? 'Unknown error'} (source: ${interpreted.payload.source ?? sourcePath})`;
+            return {
+                success: false,
+                message: errorMessage,
+                error: errorMessage,
+                details: bestEffortInterpretedText(interpreted)
+            };
+        }
+        catch (err) {
+            return { success: false, error: `Failed to import asset: ${err}` };
+        }
+        finally {
+            if (createdTestFile) {
                 try {
-                    const parsed = JSON.parse(match[1].replace(/'/g, '"'));
-                    if (parsed.success) {
-                        const count = parsed.imported?.count ?? 0;
-                        const paths = parsed.imported?.paths ?? [];
-                        return { success: true, message: `Imported ${count} assets to ${cleanDest}`, paths };
-                    }
-                    else {
-                        return { error: `Import failed: ${parsed.error || 'Unknown error'} (source: ${parsed.source || sourcePath})` };
-                    }
+                    await fs.rm(sourcePath, { force: true });
                 }
-                catch {
-                    // Fall through
+                catch (cleanupError) {
+                    // Swallow cleanup error but log for debug visibility
+                    console.warn(`Failed to clean up temporary FBX ${sourcePath}:`, cleanupError);
                 }
             }
-            // If unable to parse, return generic attempt result
-            return { error: `Import did not report success for source ${sourcePath}` };
-        }
-        catch (err) {
-            return { error: `Failed to import asset: ${err}` };
         }
     }
     async duplicateAsset(sourcePath, destinationPath) {
@@ -239,7 +250,7 @@ except Exception as e:
             return { error: `Failed to save asset: ${err}` };
         }
     }
-    createTestFBX(filePath) {
+    async createTestFBX(filePath) {
         // Create a minimal valid FBX ASCII file for testing
         const fbxContent = `; FBX 7.5.0 project file
 FBXHeaderExtension:  {
@@ -294,11 +305,12 @@ Connections:  {
 `;
         // Ensure directory exists
         const dir = path.dirname(filePath);
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
+        try {
+            await fs.mkdir(dir, { recursive: true });
         }
+        catch { }
         // Write the FBX file
-        fs.writeFileSync(filePath, fbxContent, 'utf8');
+        await fs.writeFile(filePath, fbxContent, 'utf8');
     }
 }
 //# sourceMappingURL=assets.js.map

package/dist/tools/audio.d.ts

@@ -2,7 +2,7 @@ import { UnrealBridge } from '../unreal-bridge.js';
 export declare class AudioTools {
     private bridge;
     constructor(bridge: UnrealBridge);
-    private _executeCommand;
+    private interpretResult;
     createSoundCue(params: {
         name: string;
         wavePath?: string;
@@ -14,13 +14,16 @@ export declare class AudioTools {
             attenuationSettings?: string;
         };
     }): Promise<{
-        success: boolean;
+        success: true;
         message: string;
-        error?: undefined;
+        details?: string;
+    } | {
+        success: false;
+        error: string;
+        details?: string;
     } | {
         success: boolean;
-        error: any;
-        message?: undefined;
+        error: string;
     }>;
     playSoundAtLocation(params: {
         soundPath: string;
@@ -29,13 +32,16 @@ export declare class AudioTools {
         pitch?: number;
         startTime?: number;
     }): Promise<{
-        success: boolean;
+        success: true;
         message: string;
-        error?: undefined;
+        details?: string;
+    } | {
+        success: false;
+        error: string;
+        details?: string;
     } | {
         success: boolean;
-        error: any;
-        message?: undefined;
+        error: string;
     }>;
     playSound2D(params: {
         soundPath: string;
@@ -43,13 +49,16 @@ export declare class AudioTools {
         pitch?: number;
         startTime?: number;
     }): Promise<{
-        success: boolean;
+        success: true;
         message: string;
-        error?: undefined;
+        details?: string;
+    } | {
+        success: false;
+        error: string;
+        details?: string;
     } | {
         success: boolean;
-        error: any;
-        message?: undefined;
+        error: string;
     }>;
     createAudioComponent(params: {
         actorName: string;