unreal-engine-mcp-server 0.4.6 → 0.5.0

package/src/tools/debug.ts

@@ -1,99 +1,40 @@
 // Debug visualization tools for Unreal Engine
+// Uses Automation Bridge and console commands for all operations
+
 import { UnrealBridge } from '../unreal-bridge.js';
-import { bestEffortInterpretedText, coerceString, interpretStandardResult } from '../utils/result-helpers.js';
-import { parseStandardResult } from '../utils/python-output.js';
+import { AutomationBridge } from '../automation/index.js';
 
 export class DebugVisualizationTools {
-  constructor(private bridge: UnrealBridge) {}
-
-  // Helper to draw via Python SystemLibrary with the editor world
-  private async pyDraw(scriptBody: string, meta?: { action: string; params?: Record<string, unknown> }) {
-    const action = (meta?.action || 'debug_draw').replace(/\\/g, '\\\\').replace(/'/g, "\\'");
-    const payloadObject = meta?.params ?? {};
-    const payloadJson = JSON.stringify(payloadObject).replace(/\\/g, '\\\\').replace(/'/g, "\\'");
-    const indentedBody = scriptBody
-      .split(/\r?\n/)
-      .map(line => `    ${line}`)
-      .join('\n');
-
-    const script = `
-import unreal
-import json
-
-payload = json.loads('${payloadJson}')
-ues = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-if not ues:
-    raise Exception('UnrealEditorSubsystem not available')
-world = ues.get_editor_world()
-if not world:
-    raise Exception('Editor world unavailable')
-try:
-${indentedBody}
-    print('DEBUG_DRAW:' + json.dumps({'action': '${action}', 'params': payload}))
-    print('RESULT:' + json.dumps({'success': True, 'action': '${action}', 'params': payload}))
-except Exception as e:
-    print('DEBUG_DRAW_ERROR:' + str(e))
-    print('RESULT:' + json.dumps({'success': False, 'action': '${action}', 'error': str(e)}))
-`.trim()
-      .replace(/\r?\n/g, '\n');
+  private bridge: UnrealBridge;
+  private automationBridge?: AutomationBridge;
 
-    try {
-      const response = await this.bridge.executePython(script);
-      let interpreted = interpretStandardResult(response, {
-        successMessage: `${action} executed`,
-        failureMessage: `${action} failed`
-      });
+  constructor(bridge: UnrealBridge) {
+    this.bridge = bridge;
+  }
 
-      const parsed = parseStandardResult(response);
-      const parsedPayload = parsed.data ?? {};
-      const parsedSuccessValue = (parsedPayload as any).success;
-      const normalizedSuccess = typeof parsedSuccessValue === 'string'
-        ? ['true', '1', 'yes'].includes(parsedSuccessValue.toLowerCase())
-        : parsedSuccessValue === true;
-
-      if (!interpreted.success && normalizedSuccess) {
-        interpreted = {
-          ...interpreted,
-          success: true,
-          error: undefined,
-          message: interpreted.message || `${action} executed`,
-          payload: { ...parsedPayload }
-        };
-      }
+  setAutomationBridge(automationBridge: AutomationBridge) {
+    this.automationBridge = automationBridge;
+  }
 
-      const finalSuccess = interpreted.success || normalizedSuccess;
-
-  const resolvedAction = coerceString(interpreted.payload.action) ?? action;
-  const fallbackOutput = typeof parsed.text === 'string' ? parsed.text : '';
-  const rawOutput = bestEffortInterpretedText(interpreted) ?? (fallbackOutput ? fallbackOutput : undefined);
-
-      if (finalSuccess) {
-        return {
-          ...interpreted.payload,
-          success: true,
-          action: resolvedAction,
-          warnings: interpreted.warnings,
-          details: interpreted.details,
-          rawOutput,
-          raw: parsed.raw ?? interpreted.raw
-        };
-      }
+  // Helper to use Automation Bridge for debug operations
+  private async useAutomationBridge(action: string, params: any) {
+    if (!this.automationBridge) {
+      return { success: false, error: 'AUTOMATION_BRIDGE_NOT_AVAILABLE', message: 'Automation Bridge not available for debug operations' };
+    }
 
-      return {
-        success: false,
-        action: resolvedAction,
-        error: interpreted.error ?? `${resolvedAction} failed`,
-        warnings: interpreted.warnings,
-        details: interpreted.details,
-        rawOutput,
-        raw: parsed.raw ?? interpreted.raw
-      };
-    } catch (e) {
-      return { success: false, error: String(e), action: meta?.action || 'debug_draw' };
+    try {
+      const response = await this.automationBridge.sendAutomationRequest('create_effect', {
+        action: 'debug_shape',
+        shapeType: action,
+        ...params
+      });
+      return response;
+    } catch (error) {
+      return { success: false, error: 'AUTOMATION_BRIDGE_ERROR', message: String(error) };
     }
   }
 
-  // Draw debug line using Python SystemLibrary
+  // Draw debug line using Automation Bridge
   async drawDebugLine(params: {
     start: [number, number, number];
     end: [number, number, number];
@@ -104,17 +45,24 @@ except Exception as e:
     const color = params.color || [255, 0, 0, 255];
     const duration = params.duration ?? 5.0;
     const thickness = params.thickness ?? 1.0;
-    const [sr, sg, sb, sa] = color;
-    const [sx, sy, sz] = params.start;
-    const [ex, ey, ez] = params.end;
-    const script = `
-start = unreal.Vector(${sx}, ${sy}, ${sz})
-end = unreal.Vector(${ex}, ${ey}, ${ez})
-color = unreal.LinearColor(${sr}/255.0, ${sg}/255.0, ${sb}/255.0, ${sa}/255.0)
-unreal.SystemLibrary.draw_debug_line(world, start, end, color, ${duration}, ${thickness})
-`;
-    return this.pyDraw(script, {
-      action: 'debug_line',
+
+    // Try Automation Bridge first
+    const result = await this.useAutomationBridge('line', {
+      start: params.start,
+      end: params.end,
+      color,
+      duration,
+      thickness
+    });
+
+    if (result.success) {
+      return result;
+    }
+
+    return {
+      success: false,
+      error: result.error || 'AUTOMATION_BRIDGE_REQUIRED',
+      message: result.message || 'Drawing debug lines requires Automation Bridge debug_shape handler',
       params: {
         start: params.start,
         end: params.end,
@@ -122,10 +70,10 @@ unreal.SystemLibrary.draw_debug_line(world, start, end, color, ${duration}, ${th
         duration,
         thickness
       }
-    });
+    };
   }
 
-  // Draw debug box using Python SystemLibrary
+  // Draw debug box using Automation Bridge
   async drawDebugBox(params: {
     center: [number, number, number];
     extent: [number, number, number];
@@ -138,19 +86,24 @@ unreal.SystemLibrary.draw_debug_line(world, start, end, color, ${duration}, ${th
     const rotation = params.rotation || [0, 0, 0];
     const duration = params.duration ?? 5.0;
     const thickness = params.thickness ?? 1.0;
-    const [cr, cg, cb, ca] = color;
-    const [cx, cy, cz] = params.center;
-    const [ex, ey, ez] = params.extent;
-    const [rp, ry, rr] = rotation;
-    const script = `
-center = unreal.Vector(${cx}, ${cy}, ${cz})
-extent = unreal.Vector(${ex}, ${ey}, ${ez})
-rot = unreal.Rotator(${rp}, ${ry}, ${rr})
-color = unreal.LinearColor(${cr}/255.0, ${cg}/255.0, ${cb}/255.0, ${ca}/255.0)
-unreal.SystemLibrary.draw_debug_box(world, center, extent, color, rot, ${duration}, ${thickness})
-`;
-    return this.pyDraw(script, {
-      action: 'debug_box',
+
+    const result = await this.useAutomationBridge('box', {
+      center: params.center,
+      extent: params.extent,
+      rotation,
+      color,
+      duration,
+      thickness
+    });
+
+    if (result.success) {
+      return result;
+    }
+
+    return {
+      success: false,
+      error: result.error || 'AUTOMATION_BRIDGE_REQUIRED',
+      message: result.message || 'Drawing debug boxes requires Automation Bridge debug_shape handler',
       params: {
         center: params.center,
         extent: params.extent,
@@ -159,10 +112,10 @@ unreal.SystemLibrary.draw_debug_box(world, center, extent, color, rot, ${duratio
         duration,
         thickness
       }
-    });
+    };
   }
 
-  // Draw debug sphere using Python SystemLibrary
+  // Draw debug sphere using Automation Bridge
   async drawDebugSphere(params: {
     center: [number, number, number];
     radius: number;
@@ -175,15 +128,24 @@ unreal.SystemLibrary.draw_debug_box(world, center, extent, color, rot, ${duratio
     const color = params.color || [0, 0, 255, 255];
     const duration = params.duration ?? 5.0;
     const thickness = params.thickness ?? 1.0;
-    const [cr, cg, cb, ca] = color;
-    const [cx, cy, cz] = params.center;
-    const script = `
-center = unreal.Vector(${cx}, ${cy}, ${cz})
-color = unreal.LinearColor(${cr}/255.0, ${cg}/255.0, ${cb}/255.0, ${ca}/255.0)
-unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segments}, color, ${duration}, ${thickness})
-`;
-    return this.pyDraw(script, {
-      action: 'debug_sphere',
+
+    const result = await this.useAutomationBridge('sphere', {
+      center: params.center,
+      radius: params.radius,
+      segments,
+      color,
+      duration,
+      thickness
+    });
+
+    if (result.success) {
+      return result;
+    }
+
+    return {
+      success: false,
+      error: result.error || 'AUTOMATION_BRIDGE_REQUIRED',
+      message: result.message || 'Drawing debug spheres requires Automation Bridge debug_shape handler',
       params: {
         center: params.center,
         radius: params.radius,
@@ -192,11 +154,9 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
         duration,
         thickness
       }
-    });
+    };
   }
 
-  // The rest keep console-command fallbacks or editor helpers as before
-
   async drawDebugCapsule(params: {
     center: [number, number, number];
     halfHeight: number;
@@ -208,12 +168,24 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
     const rotation = params.rotation || [0, 0, 0];
     const color = params.color || [255, 255, 0, 255];
     const duration = params.duration || 5.0;
-    const [cx, cy, cz] = params.center;
-    const [rp, ry, rr] = rotation;
-    const [cr, cg, cb, ca] = color;
-    const script = `\ncenter = unreal.Vector(${cx}, ${cy}, ${cz})\nrot = unreal.Rotator(${rp}, ${ry}, ${rr})\ncolor = unreal.LinearColor(${cr}/255.0, ${cg}/255.0, ${cb}/255.0, ${ca}/255.0)\nunreal.SystemLibrary.draw_debug_capsule(world, center, ${params.halfHeight}, ${params.radius}, rot, color, ${duration}, 1.0)\n`;
-    return this.pyDraw(script, {
-      action: 'debug_capsule',
+
+    const result = await this.useAutomationBridge('capsule', {
+      center: params.center,
+      halfHeight: params.halfHeight,
+      radius: params.radius,
+      rotation,
+      color,
+      duration
+    });
+
+    if (result.success) {
+      return result;
+    }
+
+    return {
+      success: false,
+      error: result.error || 'AUTOMATION_BRIDGE_REQUIRED',
+      message: result.message || 'Drawing debug capsules requires Automation Bridge debug_shape handler',
       params: {
         center: params.center,
         halfHeight: params.halfHeight,
@@ -222,7 +194,7 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
         color,
         duration
       }
-    });
+    };
   }
 
   async drawDebugCone(params: {
@@ -237,12 +209,26 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
   }) {
     const color = params.color || [255, 0, 255, 255];
     const duration = params.duration || 5.0;
-    const [ox, oy, oz] = params.origin;
-    const [dx, dy, dz] = params.direction;
-    const [cr, cg, cb, ca] = color;
-    const script = `\norigin = unreal.Vector(${ox}, ${oy}, ${oz})\ndir = unreal.Vector(${dx}, ${dy}, ${dz})\ncolor = unreal.LinearColor(${cr}/255.0, ${cg}/255.0, ${cb}/255.0, ${ca}/255.0)\nunreal.SystemLibrary.draw_debug_cone(world, origin, dir, ${params.length}, ${params.angleWidth}, ${params.angleHeight}, ${params.numSides || 12}, color, ${duration}, 1.0)\n`;
-    return this.pyDraw(script, {
-      action: 'debug_cone',
+
+    const result = await this.useAutomationBridge('cone', {
+      origin: params.origin,
+      direction: params.direction,
+      length: params.length,
+      angleWidth: params.angleWidth,
+      angleHeight: params.angleHeight,
+      numSides: params.numSides || 12,
+      color,
+      duration
+    });
+
+    if (result.success) {
+      return result;
+    }
+
+    return {
+      success: false,
+      error: result.error || 'AUTOMATION_BRIDGE_REQUIRED',
+      message: result.message || 'Drawing debug cones requires Automation Bridge debug_shape handler',
       params: {
         origin: params.origin,
         direction: params.direction,
@@ -253,7 +239,7 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
         color,
         duration
       }
-    });
+    };
   }
 
   async drawDebugString(params: {
@@ -265,11 +251,23 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
   }) {
     const color = params.color || [255, 255, 255, 255];
     const duration = params.duration || 5.0;
-    const [x, y, z] = params.location;
-    const [r, g, b, a] = color;
-    const script = `\nloc = unreal.Vector(${x}, ${y}, ${z})\ncolor = unreal.LinearColor(${r}/255.0, ${g}/255.0, ${b}/255.0, ${a}/255.0)\nunreal.SystemLibrary.draw_debug_string(world, loc, "${params.text.replace(/"/g, '\\"')}", None, color, ${duration})\n`;
-    return this.pyDraw(script, {
-      action: 'debug_string',
+
+    const result = await this.useAutomationBridge('string', {
+      location: params.location,
+      text: params.text,
+      color,
+      duration,
+      fontSize: params.fontSize
+    });
+
+    if (result.success) {
+      return result;
+    }
+
+    return {
+      success: false,
+      error: result.error || 'AUTOMATION_BRIDGE_REQUIRED',
+      message: result.message || 'Drawing debug strings requires Automation Bridge debug_shape handler',
       params: {
         location: params.location,
         text: params.text,
@@ -277,7 +275,7 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
         duration,
         fontSize: params.fontSize
       }
-    });
+    };
   }
 
   async drawDebugArrow(params: {
@@ -291,12 +289,24 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
     const color = params.color || [0, 255, 255, 255];
     const duration = params.duration || 5.0;
     const thickness = params.thickness || 2.0;
-    const [sx, sy, sz] = params.start;
-    const [ex, ey, ez] = params.end;
-    const [r, g, b, a] = color;
-    const script = `\nstart = unreal.Vector(${sx}, ${sy}, ${sz})\nend = unreal.Vector(${ex}, ${ey}, ${ez})\ncolor = unreal.LinearColor(${r}/255.0, ${g}/255.0, ${b}/255.0, ${a}/255.0)\nunreal.SystemLibrary.draw_debug_arrow(world, start, end, ${params.arrowSize || 10.0}, color, ${duration}, ${thickness})\n`;
-    return this.pyDraw(script, {
-      action: 'debug_arrow',
+
+    const result = await this.useAutomationBridge('arrow', {
+      start: params.start,
+      end: params.end,
+      arrowSize: params.arrowSize || 10.0,
+      color,
+      duration,
+      thickness
+    });
+
+    if (result.success) {
+      return result;
+    }
+
+    return {
+      success: false,
+      error: result.error || 'AUTOMATION_BRIDGE_REQUIRED',
+      message: result.message || 'Drawing debug arrows requires Automation Bridge debug_shape handler',
       params: {
         start: params.start,
         end: params.end,
@@ -305,7 +315,7 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
         duration,
         thickness
       }
-    });
+    };
   }
 
   async drawDebugPoint(params: {
@@ -317,18 +327,29 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
     const size = params.size || 10.0;
     const color = params.color || [255, 255, 255, 255];
     const duration = params.duration || 5.0;
-    const [x, y, z] = params.location;
-    const [r, g, b, a] = color;
-    const script = `\nloc = unreal.Vector(${x}, ${y}, ${z})\ncolor = unreal.LinearColor(${r}/255.0, ${g}/255.0, ${b}/255.0, ${a}/255.0)\nunreal.SystemLibrary.draw_debug_point(world, loc, ${size}, color, ${duration})\n`;
-    return this.pyDraw(script, {
-      action: 'debug_point',
+
+    const result = await this.useAutomationBridge('point', {
+      location: params.location,
+      size,
+      color,
+      duration
+    });
+
+    if (result.success) {
+      return result;
+    }
+
+    return {
+      success: false,
+      error: result.error || 'AUTOMATION_BRIDGE_REQUIRED',
+      message: result.message || 'Drawing debug points requires Automation Bridge debug_shape handler',
       params: {
         location: params.location,
         size,
         color,
         duration
       }
-    });
+    };
   }
 
   async drawDebugCoordinateSystem(params: {
@@ -338,12 +359,15 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
     duration?: number;
     thickness?: number;
   }) {
-    const rotation = params.rotation || [0, 0, 0];
-    const scale = params.scale || 100.0;
-    const duration = params.duration || 5.0;
-    const thickness = params.thickness || 2.0;
-    const command = `DrawDebugCoordinateSystem ${params.location.join(' ')} ${rotation.join(' ')} ${scale} ${duration} ${thickness}`;
-    return this.bridge.executeConsoleCommand(command);
+    const result = await this.useAutomationBridge('coordinate_system', {
+      location: params.location,
+      rotation: params.rotation || [0, 0, 0],
+      scale: params.scale || 1.0,
+      duration: params.duration || 5.0,
+      thickness: params.thickness || 1.0
+    });
+
+    return result;
   }
 
   async drawDebugFrustum(params: {
@@ -361,12 +385,26 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
     const farPlane = params.farPlane || 1000.0;
     const color = params.color || [128, 128, 255, 255];
     const duration = params.duration || 5.0;
-    const [ox, oy, oz] = params.origin;
-    const [rp, ry, rr] = params.rotation;
-    const [r, g, b, a] = color;
-    const script = `\norigin = unreal.Vector(${ox}, ${oy}, ${oz})\nrot = unreal.Rotator(${rp}, ${ry}, ${rr})\ncolor = unreal.LinearColor(${r}/255.0, ${g}/255.0, ${b}/255.0, ${a}/255.0)\nunreal.SystemLibrary.draw_debug_frustum(world, origin, rot, ${params.fov}, ${aspectRatio}, ${nearPlane}, ${farPlane}, color, ${duration})\n`;
-    return this.pyDraw(script, {
-      action: 'debug_frustum',
+
+    const result = await this.useAutomationBridge('frustum', {
+      origin: params.origin,
+      rotation: params.rotation,
+      fov: params.fov,
+      aspectRatio,
+      nearPlane,
+      farPlane,
+      color,
+      duration
+    });
+
+    if (result.success) {
+      return result;
+    }
+
+    return {
+      success: false,
+      error: result.error || 'AUTOMATION_BRIDGE_REQUIRED',
+      message: result.message || 'Drawing debug frustums requires Automation Bridge debug_shape handler',
       params: {
         origin: params.origin,
         rotation: params.rotation,
@@ -377,10 +415,17 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
         color,
         duration
       }
-    });
+    };
   }
 
   async clearDebugDrawings() {
+    if (this.automationBridge) {
+      const response = await this.automationBridge.sendAutomationRequest('clear_debug_shapes', {});
+      if (response.success) {
+        return response;
+      }
+    }
+
     return this.bridge.executeConsoleCommand('FlushPersistentDebugLines');
   }
 
@@ -388,7 +433,7 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
     enabled: boolean;
     type?: 'Simple' | 'Complex' | 'Both';
   }) {
-  const commands: string[] = [];
+    const commands: string[] = [];
     if (params.enabled) {
       const typeCmd = params.type === 'Simple' ? '1' : params.type === 'Complex' ? '2' : '3';
       commands.push(`show Collision ${typeCmd}`);
@@ -429,7 +474,7 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
     ];
     if (UNSAFE_VIEWMODES.includes(params.mode)) {
       console.error(`⚠️ Viewmode '${params.mode}' may be unstable in some UE configurations.`);
-      try { await this.bridge.executeConsoleCommand('stop'); } catch {}
+      try { await this.bridge.executeConsoleCommand('stop'); } catch { }
       await new Promise(resolve => setTimeout(resolve, 100));
     }
 
@@ -471,12 +516,31 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
     const color = params.color || [255, 128, 0, 255];
     const duration = params.duration || 5.0;
     const thickness = params.thickness || 2.0;
-    for (let i = 0; i < params.points.length - 1; i++) {
-      const start = params.points[i];
-      const end = params.points[i + 1];
-      await this.drawDebugLine({ start, end, color, duration, thickness });
+
+    // Try Automation Bridge for path drawing
+    const result = await this.useAutomationBridge('path', {
+      points: params.points,
+      color,
+      duration,
+      thickness
+    });
+
+    if (result.success) {
+      return result;
     }
-    return { success: true, message: `Debug path drawn with ${params.points.length} points` };
+
+    // If Automation Bridge is unavailable or fails, do not claim success
+    return {
+      success: false,
+      error: result.error || 'AUTOMATION_BRIDGE_REQUIRED',
+      message: result.message || 'Drawing debug paths requires Automation Bridge debug_shape handler',
+      params: {
+        points: params.points,
+        color,
+        duration,
+        thickness
+      }
+    };
   }
 
   async showNavigationMesh(params: { enabled: boolean; }) {
@@ -492,18 +556,59 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
     color?: [number, number, number, number];
   }) {
     if (params.enabled && params.message) {
-      const key = params.key || -1;
-      const duration = params.duration || 5.0;
-      const color = params.color || [255, 255, 255, 255];
-      const command = `ke * DisplayDebugMessage ${key} "${params.message}" ${duration} ${color.join(' ')}`;
-      return this.bridge.executeConsoleCommand(command);
-    } else {
-      return this.bridge.executeConsoleCommand('DisableAllScreenMessages');
+      // Use Automation Bridge for on-screen messages
+      const result = await this.useAutomationBridge('message', {
+        message: params.message,
+        duration: params.duration || 5.0,
+        color: params.color || [255, 255, 255, 255]
+      });
+
+      if (result.success) {
+        return result;
+      }
+
+      return {
+        success: false,
+        error: 'AUTOMATION_BRIDGE_REQUIRED',
+        message: 'Showing on-screen messages requires Automation Bridge'
+      };
     }
+
+    const command = params.enabled ? 'EnableAllScreenMessages' : 'DisableAllScreenMessages';
+    return this.bridge.executeConsoleCommand(command);
   }
 
   async showSkeletalMeshBones(params: { actorName: string; enabled: boolean; }) {
-    const command = params.enabled ? `ShowDebugSkelMesh ${params.actorName}` : `HideDebugSkelMesh ${params.actorName}`;
-    return this.bridge.executeConsoleCommand(command);
+    // Use Automation Bridge for skeletal mesh visualization
+    const result = await this.useAutomationBridge('skeletal_meshes', {
+      actorName: params.actorName,
+      enabled: params.enabled
+    });
+
+    if (result.success) {
+      return result;
+    }
+
+    return {
+      success: false,
+      error: 'AUTOMATION_BRIDGE_REQUIRED',
+      message: 'Showing skeletal mesh bones requires Automation Bridge'
+    };
+  }
+
+  async clearDebugShapes() {
+    if (this.automationBridge) {
+      const response = await this.automationBridge.sendAutomationRequest('clear_debug_shapes', {});
+      if (response.success) {
+        return response;
+      }
+    }
+
+    try {
+      await this.bridge.executeConsoleCommand('FlushPersistentDebugLines');
+      return { success: true, message: 'Debug shapes cleared' };
+    } catch (err) {
+      return { success: false, error: `Failed to clear debug shapes: ${err}` };
+    }
   }
 }