unreal-engine-mcp-server 0.4.7 → 0.5.1

package/src/tools/performance.ts

@@ -1,17 +1,39 @@
 // Performance tools for Unreal Engine
 import { UnrealBridge } from '../unreal-bridge.js';
-import { coerceBoolean, coerceNumber, interpretStandardResult } from '../utils/result-helpers.js';
+import { AutomationBridge } from '../automation/index.js';
+import { Logger } from '../utils/logger.js';
 
 export class PerformanceTools {
-  constructor(private bridge: UnrealBridge) {}
+  private log = new Logger('PerformanceTools');
+  private automationBridge?: AutomationBridge;
+
+  constructor(private bridge: UnrealBridge, automationBridge?: AutomationBridge) {
+    this.automationBridge = automationBridge;
+  }
+
+  setAutomationBridge(automationBridge?: AutomationBridge) {
+    this.automationBridge = automationBridge;
+  }
 
   // Start profiling
   async startProfiling(params: {
     type: 'CPU' | 'GPU' | 'Memory' | 'RenderThread' | 'GameThread' | 'All';
     duration?: number;
   }) {
-  const commands: string[] = [];
-    
+    if (this.automationBridge) {
+      try {
+        const response = await this.automationBridge.sendAutomationRequest('start_profiling', {
+          type: params.type,
+          duration: params.duration
+        });
+        if (response.success) return { success: true, message: `${params.type} profiling started (bridge)` };
+      } catch (_e) {
+        // Fallback
+      }
+    }
+
+    const commands: string[] = [];
+
     switch (params.type) {
       case 'CPU':
         commands.push('stat startfile');
@@ -34,25 +56,34 @@ export class PerformanceTools {
         commands.push('stat memory');
         break;
     }
-    
+
     if (params.duration) {
       commands.push(`stat stopfile ${params.duration}`);
     }
-    
+
     await this.bridge.executeConsoleCommands(commands);
-    
+
     return { success: true, message: `${params.type} profiling started` };
   }
 
   // Stop profiling
   async stopProfiling() {
+    if (this.automationBridge) {
+      try {
+        const response = await this.automationBridge.sendAutomationRequest('stop_profiling', {});
+        if (response.success) return { success: true, message: 'Profiling stopped (bridge)' };
+      } catch (_e) {
+        // Fallback
+      }
+    }
+
     const commands = [
       'stat stopfile',
       'stat none'
     ];
-    
+
     await this.bridge.executeConsoleCommands(commands);
-    
+
     return { success: true, message: 'Profiling stopped' };
   }
 
@@ -62,27 +93,43 @@ export class PerformanceTools {
     verbose?: boolean;
   }) {
     const startTime = Date.now();
-    console.log('[PerformanceTools] Starting showFPS with params:', params);
-    
+    this.log.debug('Starting showFPS with params:', params);
+
+    if (this.automationBridge) {
+      try {
+        const response = await this.automationBridge.sendAutomationRequest('show_fps', {
+          enabled: params.enabled,
+          verbose: params.verbose
+        });
+        if (response.success) return {
+          success: true,
+          message: params.enabled ? 'FPS display enabled (bridge)' : 'FPS display disabled (bridge)',
+          fpsVisible: params.enabled
+        };
+      } catch (_e) {
+        // Fallback
+      }
+    }
+
     try {
       // Use stat fps as requested - shows FPS counter
       // For more detailed timing info, use 'stat unit' instead
-      const command = params.enabled 
+      const command = params.enabled
         ? (params.verbose ? 'stat unit' : 'stat fps')
         : 'stat none';
-      
-      console.log(`[PerformanceTools] Executing command: ${command}`);
+
+      this.log.debug(`Executing command: ${command}`);
       await this.bridge.executeConsoleCommand(command);
-      console.log(`[PerformanceTools] Command completed in ${Date.now() - startTime}ms`);
-      return { 
-        success: true, 
+      this.log.debug(`Command completed in ${Date.now() - startTime}ms`);
+      return {
+        success: true,
         message: params.enabled ? 'FPS display enabled' : 'FPS display disabled',
         fpsVisible: params.enabled,
         command: command
       };
     } catch (error) {
-      return { 
-        success: false, 
+      return {
+        success: false,
         error: `Failed to ${params.enabled ? 'enable' : 'disable'} FPS display: ${error}`,
         fpsVisible: false
       };
@@ -94,10 +141,22 @@ export class PerformanceTools {
     category: 'Unit' | 'FPS' | 'Memory' | 'Game' | 'Slate' | 'Engine' | 'RHI' | 'Streaming' | 'SceneRendering' | 'Physics' | 'Navigation' | 'Particles' | 'Audio';
     enabled: boolean;
   }) {
-    const command = params.enabled 
+    if (this.automationBridge) {
+      try {
+        const response = await this.automationBridge.sendAutomationRequest('show_stats', {
+          category: params.category,
+          enabled: params.enabled
+        });
+        if (response.success) return { success: true, message: `Stat '${params.category}' configured (bridge)` };
+      } catch (_e) {
+        // Fallback
+      }
+    }
+
+    const command = params.enabled
       ? `stat ${params.category.toLowerCase()}`
       : 'stat none';
-    
+
     return this.bridge.executeConsoleCommand(command);
   }
 
@@ -106,6 +165,18 @@ export class PerformanceTools {
     category: 'ViewDistance' | 'AntiAliasing' | 'PostProcessing' | 'PostProcess' | 'Shadows' | 'GlobalIllumination' | 'Reflections' | 'Textures' | 'Effects' | 'Foliage' | 'Shading';
     level: 0 | 1 | 2 | 3 | 4; // 0=Low, 1=Medium, 2=High, 3=Epic, 4=Cinematic
   }) {
+    if (this.automationBridge) {
+      try {
+        const response = await this.automationBridge.sendAutomationRequest('set_scalability', {
+          category: params.category,
+          level: params.level
+        });
+        if (response.success) return { success: true, message: `${params.category} quality set to level ${params.level} (bridge)` };
+      } catch (_e) {
+        // Fallback
+      }
+    }
+
     // Map incoming category to the base name expected by "sg.<Base>Quality"
     // Note: Several CVars use singular form (Shadow/Texture/Reflection)
     const categoryBaseMap: Record<string, string> = {
@@ -130,115 +201,60 @@ export class PerformanceTools {
     }
 
     const base = categoryBaseMap[params.category] || params.category;
-    
+
     // Use direct console command to set with highest priority (SetByConsole)
     // This avoids conflicts with the scalability system
     const setCommand = `sg.${base}Quality ${requestedLevel}`;
-    
+
     // Apply the console command directly
     await this.bridge.executeConsoleCommand(setCommand);
-    
-    // Skip GameUserSettings entirely to avoid any scalability triggers
-    // Console command already applied with correct priority
-    /* eslint-disable no-useless-escape */
-    const py = `
-import unreal, json
-result = {'success': True, 'category': '${base}', 'requested': ${requestedLevel}, 'actual': ${requestedLevel}, 'method': 'ConsoleOnly'}
-
-# Simply verify the console variable was set correctly
-try:
-    # Try to read the console variable directly to verify it was set
-    # This doesn't trigger any scalability system
-    import sys
-    from io import StringIO
-    
-    # Capture console output
-    old_stdout = sys.stdout
-    sys.stdout = StringIO()
-    
-    # Execute console command to query the value
-    try:
-        unreal.SystemLibrary.execute_console_command(None, 'sg.${base}Quality', None)
-    except:
-        pass
-    
-    # Get the output
-    console_output = sys.stdout.getvalue()
-    sys.stdout = old_stdout
-    
-    # Parse the output to get the actual value
-    if 'sg.${base}Quality' in console_output:
-        # Extract the value from output like 'sg.ShadowQuality = "3"'
-        import re
-        match = re.search(r'sg\.${base}Quality\\s*=\\s*"(\\d+)"', console_output)
-        if match:
-            result['actual'] = int(match.group(1))
-            result['verified'] = True
-    
-    result['method'] = 'ConsoleOnly'
-except Exception as e:
-    # Even on error, the console command was applied
-    result['method'] = 'ConsoleOnly'
-    result['note'] = str(e)
-
-print('RESULT:' + json.dumps(result))
-`.trim();
-    /* eslint-enable no-useless-escape */
-
-    // Always try to apply through Python for consistency
-    try {
-      const pyResp = await this.bridge.executePython(py);
-      const interpreted = interpretStandardResult(pyResp, {
-        successMessage: `${params.category} quality set to level ${requestedLevel}`,
-        failureMessage: `Failed to set ${params.category} quality`
-      });
-
-      if (interpreted.success) {
-        const actual = coerceNumber(interpreted.payload.actual) ?? requestedLevel;
-        const verified = coerceBoolean(interpreted.payload.success, true) === true && actual === requestedLevel;
-        return {
-          success: true,
-          message: interpreted.message,
-          verified,
-          readback: actual,
-          method: (interpreted.payload.method as string) || 'ConsoleOnly'
-        };
-      }
-    } catch {
-      // Ignore Python errors and fall through
-    }
 
-    // If Python fails, the console command was still applied
-    return { 
-      success: true, 
+    return {
+      success: true,
       message: `${params.category} quality set to level ${requestedLevel}`,
-      method: 'CVarOnly'
+      method: 'Console'
     };
   }
 
   // Set resolution scale
   async setResolutionScale(params: {
-    scale: number; // 0.5 to 2.0
+    scale: number; // Accepts both percentage (10-200) and multiplier (0.1-2.0)
   }) {
     // Validate input
     if (params.scale === undefined || params.scale === null || isNaN(params.scale)) {
       return { success: false, error: 'Invalid scale parameter' };
     }
-    
-    // Clamp scale between 10% (0.1) and 200% (2.0) - Unreal Engine limits
-    // Note: r.ScreenPercentage takes values from 10 to 200, not 0.5 to 2.0
-    const clampedScale = Math.max(0.1, Math.min(2.0, params.scale));
-    const percentage = Math.round(clampedScale * 100);
-    
-    // Ensure percentage is within Unreal's valid range
+
+    // Intelligently detect if scale is a percentage (10-200) or multiplier (0.1-2.0)
+    // If scale >= 10, assume it's already a percentage value
+    let percentage: number;
+    if (params.scale >= 10) {
+      // User passed percentage directly (e.g., 100 for 100%)
+      percentage = Math.round(params.scale);
+    } else {
+      // User passed multiplier (e.g., 1.0 for 100%)
+      percentage = Math.round(params.scale * 100);
+    }
+
+    // Clamp to Unreal's valid range (10-200%)
     const finalPercentage = Math.max(10, Math.min(200, percentage));
-    
+
+    if (this.automationBridge) {
+      try {
+        const response = await this.automationBridge.sendAutomationRequest('set_resolution_scale', { scale: finalPercentage });
+
+        if (response.success) return { success: true, message: `Resolution scale set to ${finalPercentage}% (bridge)`, actualScale: finalPercentage / 100 };
+      } catch (_e) {
+        // Fallback
+      }
+    }
+
     const command = `r.ScreenPercentage ${finalPercentage}`;
-    
+
     try {
       await this.bridge.executeConsoleCommand(command);
-      return { 
-        success: true, 
+      return {
+        success: true,
         message: `Resolution scale set to ${finalPercentage}%`,
         actualScale: finalPercentage / 100
       };
@@ -251,6 +267,14 @@ print('RESULT:' + json.dumps(result))
   async setVSync(params: {
     enabled: boolean;
   }) {
+    if (this.automationBridge) {
+      try {
+        const response = await this.automationBridge.sendAutomationRequest('set_vsync', { enabled: params.enabled });
+        if (response.success) return { success: true, message: 'VSync configured (bridge)' };
+      } catch (_e) {
+        // Fallback
+      }
+    }
     const command = `r.VSync ${params.enabled ? 1 : 0}`;
     return this.bridge.executeConsoleCommand(command);
   }
@@ -259,6 +283,14 @@ print('RESULT:' + json.dumps(result))
   async setFrameRateLimit(params: {
     maxFPS: number; // 0 for unlimited
   }) {
+    if (this.automationBridge) {
+      try {
+        const response = await this.automationBridge.sendAutomationRequest('set_frame_rate_limit', { maxFPS: params.maxFPS });
+        if (response.success) return { success: true, message: 'Max FPS set (bridge)' };
+      } catch (_e) {
+        // Fallback
+      }
+    }
     const command = `t.MaxFPS ${params.maxFPS}`;
     return this.bridge.executeConsoleCommand(command);
   }
@@ -267,6 +299,13 @@ print('RESULT:' + json.dumps(result))
   async enableGPUTiming(params: {
     enabled: boolean;
   }) {
+    // Note: C++ handler doesn't seem to have explicit 'enable_gpu_timing' in the list I saw earlier? 
+    // Checking McpAutomationBridge_PerformanceHandlers.cpp content provided:
+    // It has: generate_memory_report, start/stop_profiling, show_fps, show_stats, set_scalability, set_resolution_scale, set_vsync, set_frame_rate_limit, configure_nanite, configure_lod.
+    // IT DOES NOT HAVE enable_gpu_timing.
+    // So we stick to console command for this one, or add it to C++ later. 
+    // I will NOT add bridge call here to avoid failure since I know it's missing.
+
     const command = `r.GPUStatsEnabled ${params.enabled ? 1 : 0}`;
     return this.bridge.executeConsoleCommand(command);
   }
@@ -276,20 +315,41 @@ print('RESULT:' + json.dumps(result))
     detailed?: boolean;
     outputPath?: string;
   }) {
-  const commands: string[] = [];
-    
+    // If output path is specified, use Automation Bridge for file writing
+    if (this.automationBridge) {
+      try {
+        const response = await this.automationBridge.sendAutomationRequest('generate_memory_report', {
+          detailed: params.detailed ?? false,
+          outputPath: params.outputPath
+        });
+
+        // Even if no output path, bridge can run the report
+        if (response.success) {
+          return { success: true, message: response.message || 'Memory report generated' };
+        }
+      } catch (error) {
+        // Fallback only if no output path (since console can't save to file reliably)
+        if (params.outputPath) {
+          return { success: false, error: `Failed to generate memory report: ${error instanceof Error ? error.message : String(error)}` };
+        }
+      }
+    }
+
+    const commands: string[] = [];
+
     if (params.detailed) {
       commands.push('memreport -full');
     } else {
       commands.push('memreport');
     }
-    
+
+    // Writing reports to disk via console is not supported
     if (params.outputPath) {
-      commands.push(`obj savepackage ${params.outputPath}`);
+      throw new Error('Saving memreport to a file requires Automation Bridge support');
     }
-    
+
     await this.bridge.executeConsoleCommands(commands);
-    
+
     return { success: true, message: 'Memory report generated' };
   }
 
@@ -299,20 +359,34 @@ print('RESULT:' + json.dumps(result))
     poolSize?: number; // MB
     boostPlayerLocation?: boolean;
   }) {
-  const commands: string[] = [];
-    
+    if (this.automationBridge) {
+      try {
+        const response = await this.automationBridge.sendAutomationRequest('configure_texture_streaming', {
+          enabled: params.enabled,
+          poolSize: params.poolSize,
+          boostPlayerLocation: params.boostPlayerLocation
+        });
+
+        if (response.success) return { success: true, message: response.message || 'Texture streaming configured (bridge)' };
+      } catch (_error) {
+        // Fallback
+      }
+    }
+
+    if (params.boostPlayerLocation && !this.automationBridge) {
+      throw new Error('Boosting player location for streaming requires Automation Bridge support');
+    }
+
+    const commands: string[] = [];
+
     commands.push(`r.TextureStreaming ${params.enabled ? 1 : 0}`);
-    
+
     if (params.poolSize !== undefined) {
       commands.push(`r.Streaming.PoolSize ${params.poolSize}`);
     }
-    
-    if (params.boostPlayerLocation !== undefined) {
-      commands.push(`r.Streaming.UseFixedPoolSize ${params.boostPlayerLocation ? 1 : 0}`);
-    }
-    
+
     await this.bridge.executeConsoleCommands(commands);
-    
+
     return { success: true, message: 'Texture streaming configured' };
   }
 
@@ -322,25 +396,46 @@ print('RESULT:' + json.dumps(result))
     lodBias?: number; // skeletal LOD bias (int)
     distanceScale?: number; // distance scale (float) applied to both static and skeletal
   }) {
-  const commands: string[] = [];
-    
+    if (this.automationBridge) {
+      try {
+        const response = await this.automationBridge.sendAutomationRequest('configure_lod', {
+          forceLOD: params.forceLOD,
+          lodBias: params.lodBias
+          // Note: C++ handler doesn't seem to have explicit 'distanceScale'.
+          // We will stick to console for proper implementation of distanceScale
+        });
+
+        // If we have distanceScale, we still need to apply it via console as C++ seems to miss it
+        if (params.distanceScale !== undefined) {
+          await this.bridge.executeConsoleCommand(`r.StaticMeshLODDistanceScale ${params.distanceScale}`);
+          await this.bridge.executeConsoleCommand(`r.SkeletalMeshLODDistanceScale ${params.distanceScale}`);
+        }
+
+        if (response.success) return { success: true, message: 'LOD settings configured' };
+      } catch (_e) {
+        // Fallback
+      }
+    }
+
+    const commands: string[] = [];
+
     if (params.forceLOD !== undefined) {
       commands.push(`r.ForceLOD ${params.forceLOD}`);
     }
-    
+
     if (params.lodBias !== undefined) {
       // Skeletal mesh LOD bias is an integer bias value
       commands.push(`r.SkeletalMeshLODBias ${params.lodBias}`);
     }
-    
+
     if (params.distanceScale !== undefined) {
       // Apply distance scale to both static and skeletal meshes
       commands.push(`r.StaticMeshLODDistanceScale ${params.distanceScale}`);
       commands.push(`r.SkeletalMeshLODDistanceScale ${params.distanceScale}`);
     }
-    
+
     await this.bridge.executeConsoleCommands(commands);
-    
+
     return { success: true, message: 'LOD settings configured' };
   }
 
@@ -352,6 +447,8 @@ print('RESULT:' + json.dumps(result))
     maxFPS?: number;        // default 60
     hzb?: boolean;          // default true
   }) {
+    // This is a composite helper, stick to console or individual bridge calls.
+    // Console is efficient enough for batch cvar setting.
     const p = {
       distanceScale: params?.distanceScale ?? 1.0,
       skeletalBias: params?.skeletalBias ?? 0,
@@ -377,23 +474,53 @@ print('RESULT:' + json.dumps(result))
   // Draw call optimization
   async optimizeDrawCalls(params: {
     enableInstancing?: boolean;
-    enableBatching?: boolean; // no-op (deprecated internal toggle)
+
     mergeActors?: boolean;
+    actors?: string[];
   }) {
-  const commands: string[] = [];
-    
+    // If merging actors, bridge is required and actors must be provided
+    if (params.mergeActors) {
+      if (this.automationBridge) {
+        try {
+          const actors = Array.isArray(params.actors)
+            ? params.actors.filter((name): name is string => typeof name === 'string' && name.length > 0)
+            : undefined;
+
+          if (!actors || actors.length < 2) {
+            return {
+              success: false,
+              error: 'Merge actors requires an "actors" array with at least 2 valid actor names.'
+            };
+          }
+
+          const payload: any = {
+            enableInstancing: params.enableInstancing,
+            mergeActors: params.mergeActors,
+            actors: actors
+          };
+
+          const response = await this.automationBridge.sendAutomationRequest('merge_actors', payload);
+
+          return response.success
+            ? { success: true, message: response.message || 'Actors merged for optimization' }
+            : { success: false, error: response.message || response.error || 'Failed to merge actors' };
+        } catch (error) {
+          return { success: false, error: `Failed to merge actors: ${error instanceof Error ? error.message : String(error)}` };
+        }
+      }
+      throw new Error('Actor merging requires Automation Bridge support');
+    }
+
+    const commands: string[] = [];
+
     if (params.enableInstancing !== undefined) {
       commands.push(`r.MeshDrawCommands.DynamicInstancing ${params.enableInstancing ? 1 : 0}`);
     }
-    
+
     // Avoid using r.RHICmdBypass; it's a low-level debug toggle and not suitable for general batching control
-    
-    if (params.mergeActors) {
-      commands.push('MergeActors');
-    }
-    
+
     await this.bridge.executeConsoleCommands(commands);
-    
+
     return { success: true, message: 'Draw call optimization configured' };
   }
 
@@ -403,18 +530,18 @@ print('RESULT:' + json.dumps(result))
     method?: 'Hardware' | 'Software' | 'Hierarchical';
     freezeRendering?: boolean;
   }) {
-  const commands: string[] = [];
-    
+    const commands: string[] = [];
+
     // Enable/disable HZB occlusion (boolean)
     commands.push(`r.HZBOcclusion ${params.enabled ? 1 : 0}`);
-    
+
     // Optional freeze rendering toggle
     if (params.freezeRendering !== undefined) {
       commands.push(`FreezeRendering ${params.freezeRendering ? 1 : 0}`);
     }
-    
+
     await this.bridge.executeConsoleCommands(commands);
-    
+
     return { success: true, message: 'Occlusion culling configured' };
   }
 
@@ -424,22 +551,22 @@ print('RESULT:' + json.dumps(result))
     cacheShaders?: boolean;
     reducePermutations?: boolean;
   }) {
-  const commands: string[] = [];
-    
+    const commands: string[] = [];
+
     if (params.compileOnDemand !== undefined) {
       commands.push(`r.ShaderDevelopmentMode ${params.compileOnDemand ? 1 : 0}`);
     }
-    
+
     if (params.cacheShaders !== undefined) {
       commands.push(`r.ShaderPipelineCache.Enabled ${params.cacheShaders ? 1 : 0}`);
     }
-    
+
     if (params.reducePermutations) {
       commands.push('RecompileShaders changed');
     }
-    
+
     await this.bridge.executeConsoleCommands(commands);
-    
+
     return { success: true, message: 'Shader optimization configured' };
   }
 
@@ -449,20 +576,44 @@ print('RESULT:' + json.dumps(result))
     maxPixelsPerEdge?: number;
     streamingPoolSize?: number;
   }) {
-  const commands: string[] = [];
-    
+    if (this.automationBridge) {
+      try {
+        const response = await this.automationBridge.sendAutomationRequest('configure_nanite', {
+          enabled: params.enabled,
+          maxPixelsPerEdge: params.maxPixelsPerEdge,
+          streamingPoolSize: params.streamingPoolSize
+        });
+        // C++ handler snippet only showed `r.Nanite`. 
+        // Checking snippet: `if (CVar) CVar->Set(bEnabled ? 1 : 0);`
+        // It missed maxPixelsPerEdge and streamingPoolSize in the snippet I read.
+        // Let's rely on fallback or partial console commands for the extras.
+        if (params.maxPixelsPerEdge !== undefined) {
+          await this.bridge.executeConsoleCommand(`r.Nanite.MaxPixelsPerEdge ${params.maxPixelsPerEdge}`);
+        }
+        if (params.streamingPoolSize !== undefined) {
+          await this.bridge.executeConsoleCommand(`r.Nanite.StreamingPoolSize ${params.streamingPoolSize}`);
+        }
+
+        if (response.success) return { success: true, message: 'Nanite configured' };
+      } catch (_e) {
+        // Fallback
+      }
+    }
+
+    const commands: string[] = [];
+
     commands.push(`r.Nanite ${params.enabled ? 1 : 0}`);
-    
+
     if (params.maxPixelsPerEdge !== undefined) {
       commands.push(`r.Nanite.MaxPixelsPerEdge ${params.maxPixelsPerEdge}`);
     }
-    
+
     if (params.streamingPoolSize !== undefined) {
       commands.push(`r.Nanite.StreamingPoolSize ${params.streamingPoolSize}`);
     }
-    
+
     await this.bridge.executeConsoleCommands(commands);
-    
+
     return { success: true, message: 'Nanite configured' };
   }
 
@@ -472,20 +623,20 @@ print('RESULT:' + json.dumps(result))
     streamingDistance?: number;
     cellSize?: number;
   }) {
-  const commands: string[] = [];
-    
+    const commands: string[] = [];
+
     commands.push(`wp.Runtime.EnableStreaming ${params.enabled ? 1 : 0}`);
-    
+
     if (params.streamingDistance !== undefined) {
       commands.push(`wp.Runtime.StreamingDistance ${params.streamingDistance}`);
     }
-    
+
     if (params.cellSize !== undefined) {
       commands.push(`wp.Runtime.CellSize ${params.cellSize}`);
     }
-    
+
     await this.bridge.executeConsoleCommands(commands);
-    
+
     return { success: true, message: 'World Partition configured' };
   }
 
@@ -495,16 +646,16 @@ print('RESULT:' + json.dumps(result))
     outputPath?: string;
   }) {
     const duration = params.duration || 60;
-    
-  // Start recording and GPU profiling
-  await this.bridge.executeConsoleCommands(['stat startfile', 'profilegpu']);
-    
+
+    // Start recording and GPU profiling
+    await this.bridge.executeConsoleCommands(['stat startfile', 'profilegpu']);
+
     // Wait for the requested duration
     await new Promise(resolve => setTimeout(resolve, duration * 1000));
-    
+
     // Stop recording and clear stats
     await this.bridge.executeConsoleCommands(['stat stopfile', 'stat none']);
-    
+
     return { success: true, message: `Benchmark completed for ${duration} seconds` };
   }
 }