unreal-engine-mcp-server 0.5.0 → 0.5.2

package/tests/test-blueprint-graph.mjs

@@ -1,17 +1,19 @@
 #!/usr/bin/env node
 /**
- * Blueprint Graph Test Suite
- * Tools: manage_blueprint, manage_blueprint_graph
+ * Comprehensive Blueprint Graph Test Suite
+ * Tool: manage_blueprint_graph
+ * Coverage: All 9 actions with success, error, and edge cases
  */
 
 import { runToolTests } from './test-runner.mjs';
 
 // Use a unique blueprint name per run to avoid collisions
 const ts = new Date().toISOString().replace(/[^0-9]/g, '').slice(0, 12);
-const BP_NAME = `BP_Graph_${ts}`;
+const BP_NAME = `BP_GraphFull_${ts}`;
 const BP_PATH = `/Game/Blueprints/${BP_NAME}`;
 
 const testCases = [
+  // === SETUP ===
   {
     scenario: 'Create blueprint for graph tests',
     toolName: 'manage_blueprint',
@@ -25,7 +27,73 @@ const testCases = [
     expected: 'success'
   },
   {
-    scenario: 'Create Literal object node via manage_blueprint_graph',
+    scenario: 'Add variable for node tests',
+    toolName: 'manage_blueprint',
+    arguments: {
+      action: 'add_variable',
+      name: BP_PATH,
+      variableName: 'TestFloat',
+      variableType: 'Float',
+      defaultValue: 0.0
+    },
+    expected: 'success'
+  },
+  {
+    scenario: 'Add second variable',
+    toolName: 'manage_blueprint',
+    arguments: {
+      action: 'add_variable',
+      name: BP_PATH,
+      variableName: 'TestBool',
+      variableType: 'Bool',
+      defaultValue: false
+    },
+    expected: 'success'
+  },
+
+  // === GET GRAPH DETAILS ===
+  {
+    scenario: 'Get EventGraph details',
+    toolName: 'manage_blueprint_graph',
+    arguments: {
+      action: 'get_graph_details',
+      blueprintPath: BP_PATH,
+      graphName: 'EventGraph'
+    },
+    expected: 'success'
+  },
+
+  // === CREATE NODES ===
+  {
+    scenario: 'Create VariableGet node',
+    toolName: 'manage_blueprint_graph',
+    arguments: {
+      action: 'create_node',
+      blueprintPath: BP_PATH,
+      graphName: 'EventGraph',
+      nodeType: 'VariableGet',
+      memberName: 'TestFloat',
+      x: 0,
+      y: 0
+    },
+    expected: 'success'
+  },
+  {
+    scenario: 'Create VariableSet node',
+    toolName: 'manage_blueprint_graph',
+    arguments: {
+      action: 'create_node',
+      blueprintPath: BP_PATH,
+      graphName: 'EventGraph',
+      nodeType: 'VariableSet',
+      memberName: 'TestFloat',
+      x: 200,
+      y: 0
+    },
+    expected: 'success'
+  },
+  {
+    scenario: 'Create Literal node (object)',
     toolName: 'manage_blueprint_graph',
     arguments: {
       action: 'create_node',
@@ -35,10 +103,255 @@ const testCases = [
       literalType: 'object',
       objectPath: '/Engine/BasicShapes/Cube.Cube',
       x: 0,
+      y: 100
+    },
+    expected: 'success'
+  },
+  {
+    scenario: 'Create CallFunction node',
+    toolName: 'manage_blueprint_graph',
+    arguments: {
+      action: 'create_node',
+      blueprintPath: BP_PATH,
+      graphName: 'EventGraph',
+      nodeType: 'CallFunction',
+      memberName: 'PrintString',
+      x: 300,
+      y: 0
+    },
+    expected: 'success'
+  },
+  {
+    scenario: 'Create Event node (BeginPlay)',
+    toolName: 'manage_blueprint_graph',
+    arguments: {
+      action: 'create_node',
+      blueprintPath: BP_PATH,
+      graphName: 'EventGraph',
+      nodeType: 'Event',
+      memberName: 'ReceiveBeginPlay',
+      x: -200,
+      y: 0
+    },
+    expected: 'success'
+  },
+  {
+    scenario: 'Create Branch node',
+    toolName: 'manage_blueprint_graph',
+    arguments: {
+      action: 'create_node',
+      blueprintPath: BP_PATH,
+      graphName: 'EventGraph',
+      nodeType: 'Branch',
+      x: 100,
+      y: 150
+    },
+    expected: 'success'
+  },
+  {
+    scenario: 'Create Sequence node',
+    toolName: 'manage_blueprint_graph',
+    arguments: {
+      action: 'create_node',
+      blueprintPath: BP_PATH,
+      graphName: 'EventGraph',
+      nodeType: 'Sequence',
+      x: 200,
+      y: 150
+    },
+    expected: 'success'
+  },
+  {
+    scenario: 'Create ForEachLoop node',
+    toolName: 'manage_blueprint_graph',
+    arguments: {
+      action: 'create_node',
+      blueprintPath: BP_PATH,
+      graphName: 'EventGraph',
+      nodeType: 'ForEachLoop',
+      x: 300,
+      y: 150
+    },
+    expected: 'success'
+  },
+  {
+    scenario: 'Create Delay node',
+    toolName: 'manage_blueprint_graph',
+    arguments: {
+      action: 'create_node',
+      blueprintPath: BP_PATH,
+      graphName: 'EventGraph',
+      nodeType: 'Delay',
+      x: 400,
+      y: 0
+    },
+    expected: 'success'
+  },
+  {
+    scenario: 'Create SpawnActor node',
+    toolName: 'manage_blueprint_graph',
+    arguments: {
+      action: 'create_node',
+      blueprintPath: BP_PATH,
+      graphName: 'EventGraph',
+      nodeType: 'SpawnActor',
+      x: 500,
       y: 0
     },
     expected: 'success'
   },
+
+  // === CREATE REROUTE NODE ===
+  {
+    scenario: 'Create Reroute node',
+    toolName: 'manage_blueprint_graph',
+    arguments: {
+      action: 'create_reroute_node',
+      blueprintPath: BP_PATH,
+      graphName: 'EventGraph',
+      x: 150,
+      y: 50
+    },
+    expected: 'success'
+  },
+
+  // === GET NODE DETAILS ===
+  {
+    scenario: 'Get node details',
+    toolName: 'manage_blueprint_graph',
+    arguments: {
+      action: 'get_node_details',
+      blueprintPath: BP_PATH,
+      graphName: 'EventGraph'
+    },
+    expected: 'success'
+  },
+
+  // === GET PIN DETAILS ===
+  {
+    scenario: 'Get pin details',
+    toolName: 'manage_blueprint_graph',
+    arguments: {
+      action: 'get_pin_details',
+      blueprintPath: BP_PATH,
+      graphName: 'EventGraph'
+    },
+    expected: 'success'
+  },
+
+  // === SET NODE PROPERTY ===
+  {
+    scenario: 'Set Delay duration',
+    toolName: 'manage_blueprint_graph',
+    arguments: {
+      action: 'set_node_property',
+      blueprintPath: BP_PATH,
+      graphName: 'EventGraph',
+      nodeId: 'Delay_0',
+      propertyName: 'Duration',
+      value: 2.0
+    },
+    expected: 'success|not_found'
+  },
+
+  // === CONNECT PINS ===
+  {
+    scenario: 'Connect BeginPlay to SetVariable',
+    toolName: 'manage_blueprint_graph',
+    arguments: {
+      action: 'connect_pins',
+      blueprintPath: BP_PATH,
+      graphName: 'EventGraph',
+      fromPin: 'ReceiveBeginPlay.Execute',
+      linkedTo: 'SetTestFloat.Execute'
+    },
+    expected: 'success|not_found'
+  },
+
+  // === BREAK PIN LINKS ===
+  {
+    scenario: 'Break pin links',
+    toolName: 'manage_blueprint_graph',
+    arguments: {
+      action: 'break_pin_links',
+      blueprintPath: BP_PATH,
+      graphName: 'EventGraph',
+      pinName: 'SetTestFloat.Execute'
+    },
+    expected: 'success|not_found'
+  },
+
+  // === DELETE NODE ===
+  {
+    scenario: 'Delete ForEachLoop node',
+    toolName: 'manage_blueprint_graph',
+    arguments: {
+      action: 'delete_node',
+      blueprintPath: BP_PATH,
+      graphName: 'EventGraph',
+      nodeId: 'ForEachLoop_0'
+    },
+    expected: 'success|not_found'
+  },
+
+  // === ERROR CASES ===
+  {
+    scenario: 'Error: Get invalid graph details',
+    toolName: 'manage_blueprint_graph',
+    arguments: {
+      action: 'get_graph_details',
+      blueprintPath: BP_PATH,
+      graphName: 'InvalidGraphName_DOES_NOT_EXIST'
+    },
+    expected: 'error|graph_not_found'
+  },
+  {
+    scenario: 'Error: Create node in invalid graph',
+    toolName: 'manage_blueprint_graph',
+    arguments: {
+      action: 'create_node',
+      blueprintPath: BP_PATH,
+      graphName: 'NonExistentGraph',
+      nodeType: 'VariableGet',
+      memberName: 'TestFloat'
+    },
+    expected: 'error|graph_not_found'
+  },
+  {
+    scenario: 'Error: Connect invalid pins',
+    toolName: 'manage_blueprint_graph',
+    arguments: {
+      action: 'connect_pins',
+      blueprintPath: BP_PATH,
+      graphName: 'EventGraph',
+      fromPin: 'Invalid.Pin',
+      linkedTo: 'Also.Invalid'
+    },
+    expected: 'error|not_found'
+  },
+  {
+    scenario: 'Error: Delete non-existent node',
+    toolName: 'manage_blueprint_graph',
+    arguments: {
+      action: 'delete_node',
+      blueprintPath: BP_PATH,
+      graphName: 'EventGraph',
+      nodeId: 'NonExistentNode_XYZ'
+    },
+    expected: 'error|not_found'
+  },
+  {
+    scenario: 'Error: Create node in invalid blueprint',
+    toolName: 'manage_blueprint_graph',
+    arguments: {
+      action: 'create_node',
+      blueprintPath: '/Game/Blueprints/DOES_NOT_EXIST',
+      graphName: 'EventGraph',
+      nodeType: 'VariableGet',
+      memberName: 'TestFloat'
+    },
+    expected: 'error|not_found'
+  },
   {
     scenario: 'Error: Literal object path not found',
     toolName: 'manage_blueprint_graph',
@@ -54,26 +367,44 @@ const testCases = [
     },
     expected: 'error|object_not_found'
   },
+
+  // === EDGE CASES ===
   {
-    scenario: 'Get graph details via manage_blueprint_graph',
+    scenario: 'Edge: Negative node position',
     toolName: 'manage_blueprint_graph',
     arguments: {
-      action: 'get_graph_details',
+      action: 'create_node',
       blueprintPath: BP_PATH,
-      graphName: 'EventGraph'
+      graphName: 'EventGraph',
+      nodeType: 'VariableGet',
+      memberName: 'TestFloat',
+      x: -1000,
+      y: -1000
     },
     expected: 'success'
   },
   {
-    scenario: 'Error: Graph not found for manage_blueprint_graph',
+    scenario: 'Edge: Very large node position',
     toolName: 'manage_blueprint_graph',
     arguments: {
-      action: 'get_graph_details',
+      action: 'create_node',
       blueprintPath: BP_PATH,
-      graphName: 'InvalidGraphName_DOES_NOT_EXIST'
+      graphName: 'EventGraph',
+      nodeType: 'VariableGet',
+      memberName: 'TestFloat',
+      x: 10000,
+      y: 10000
     },
-    expected: 'error|graph_not_found'
+    expected: 'success'
+  },
+
+  // === CLEANUP ===
+  {
+    scenario: 'Cleanup: Delete test blueprint',
+    toolName: 'manage_asset',
+    arguments: { action: 'delete', assetPaths: [BP_PATH] },
+    expected: 'success'
   }
 ];
 
-await runToolTests('BlueprintGraph', testCases);
+await runToolTests('Blueprint Graph Full', testCases);

package/tests/test-control-editor.mjs

@@ -1,80 +1,112 @@
 #!/usr/bin/env node
 /**
- * Condensed Editor Control Test Suite (15 cases) — safe for real Editor runs.
+ * Comprehensive Editor Control Test Suite
  * Tool: control_editor
+ * Coverage: All 24 actions with success, error, and edge cases
  */
 
 import { runToolTests } from './test-runner.mjs';
 
 const testCases = [
+  // === PRE-FIX ===
   {
     scenario: 'Pre-Fix: Remove Invalid Data Layers (Native)',
     toolName: 'manage_level',
     arguments: {
       action: 'cleanup_invalid_datalayers'
     },
-    // We expect success if supported, or error if not. 
-    // Since we just added it, it should succeed if plugin is rebuilt.
-    // If plugin is NOT rebuilt yet, this will fail with valid error or "unknown action" depending on how it falls through.
-    // But since the user is expected to rebuild, we expect success.
     expected: 'success'
   },
+
+  // === PIE CONTROL (play, stop, stop_pie, pause, resume) ===
   { scenario: 'Start PIE (Play in Editor)', toolName: 'control_editor', arguments: { action: 'play' }, expected: 'success - PIE started' },
+  { scenario: 'Pause PIE', toolName: 'control_editor', arguments: { action: 'pause' }, expected: 'success - PIE paused' },
+  { scenario: 'Resume PIE', toolName: 'control_editor', arguments: { action: 'resume' }, expected: 'success - PIE resumed' },
   { scenario: 'Stop PIE', toolName: 'control_editor', arguments: { action: 'stop' }, expected: 'success - PIE stopped' },
-  { scenario: 'Set camera location', toolName: 'control_editor', arguments: { action: 'set_camera', location: { x: 0, y: 0, z: 500 }, rotation: { pitch: -45, yaw: 0, roll: 0 } }, expected: 'success - camera set' },
+  { scenario: 'Stop PIE (alias)', toolName: 'control_editor', arguments: { action: 'stop_pie' }, expected: 'success - PIE stopped' },
+
+  // === GAME SPEED ===
+  { scenario: 'Set game speed 0.5x', toolName: 'control_editor', arguments: { action: 'set_game_speed', speed: 0.5 }, expected: 'success' },
+  { scenario: 'Set game speed 2x', toolName: 'control_editor', arguments: { action: 'set_game_speed', speed: 2.0 }, expected: 'success' },
+  { scenario: 'Set game speed 1x (reset)', toolName: 'control_editor', arguments: { action: 'set_game_speed', speed: 1.0 }, expected: 'success' },
+
+  // === EJECT / POSSESS ===
+  { scenario: 'Eject from possessed pawn', toolName: 'control_editor', arguments: { action: 'eject' }, expected: 'success|handled' },
+  { scenario: 'Possess pawn', toolName: 'control_editor', arguments: { action: 'possess' }, expected: 'success|handled' },
+
+  // === CAMERA CONTROL ===
+  { scenario: 'Set camera location and rotation', toolName: 'control_editor', arguments: { action: 'set_camera', location: { x: 0, y: 0, z: 500 }, rotation: { pitch: -45, yaw: 0, roll: 0 } }, expected: 'success - camera set' },
+  { scenario: 'Set camera position only', toolName: 'control_editor', arguments: { action: 'set_camera_position', location: { x: 100, y: 100, z: 300 } }, expected: 'success' },
+  { scenario: 'Set camera rotation only', toolName: 'control_editor', arguments: { action: 'set_camera', rotation: { pitch: -30, yaw: 45, roll: 0 } }, expected: 'success' },
   { scenario: 'Focus camera on actor', toolName: 'control_editor', arguments: { action: 'set_camera', targetActor: 'TC_Cube' }, expected: 'success - camera focused' },
+  { scenario: 'Set camera FOV 90', toolName: 'control_editor', arguments: { action: 'set_camera_fov', fov: 90 }, expected: 'success' },
+  { scenario: 'Set camera FOV 60', toolName: 'control_editor', arguments: { action: 'set_camera_fov', fov: 60 }, expected: 'success' },
+  { scenario: 'Set camera FOV extreme (120)', toolName: 'control_editor', arguments: { action: 'set_camera_fov', fov: 120 }, expected: 'success' },
+
+  // === VIEW MODE ===
   { scenario: 'Set view mode to Lit', toolName: 'control_editor', arguments: { action: 'set_view_mode', viewMode: 'Lit' }, expected: 'success - view mode set' },
   { scenario: 'Set view mode to Wireframe', toolName: 'control_editor', arguments: { action: 'set_view_mode', viewMode: 'Wireframe' }, expected: 'success - view mode set' },
+  { scenario: 'Set view mode to Unlit', toolName: 'control_editor', arguments: { action: 'set_view_mode', viewMode: 'Unlit' }, expected: 'success' },
+  { scenario: 'Set view mode to PathTracing', toolName: 'control_editor', arguments: { action: 'set_view_mode', viewMode: 'PathTracing' }, expected: 'success|not_supported' },
+
+  // === VIEWPORT SETTINGS ===
+  { scenario: 'Set viewport resolution 1920x1080', toolName: 'control_editor', arguments: { action: 'set_viewport_resolution', width: 1920, height: 1080 }, expected: 'success' },
+  { scenario: 'Set viewport resolution 1280x720', toolName: 'control_editor', arguments: { action: 'set_viewport_resolution', width: 1280, height: 720 }, expected: 'success' },
+  { scenario: 'Set viewport realtime on', toolName: 'control_editor', arguments: { action: 'set_viewport_realtime', enabled: true }, expected: 'success' },
+  { scenario: 'Set viewport realtime off', toolName: 'control_editor', arguments: { action: 'set_viewport_realtime', enabled: false }, expected: 'success' },
+
+  // === SCREENSHOT ===
   { scenario: 'Take screenshot', toolName: 'control_editor', arguments: { action: 'screenshot', filename: 'TC_Screenshot' }, expected: 'success - screenshot taken' },
+  { scenario: 'Take screenshot with resolution', toolName: 'control_editor', arguments: { action: 'screenshot', filename: 'TC_Screenshot_HD', width: 1920, height: 1080 }, expected: 'success' },
+
+  // === RECORDING ===
   { scenario: 'Start recording', toolName: 'control_editor', arguments: { action: 'start_recording', filename: 'TC_Record', frameRate: 30 }, expected: 'success - recording started' },
   { scenario: 'Stop recording', toolName: 'control_editor', arguments: { action: 'stop_recording' }, expected: 'success - recording stopped' },
-  { scenario: 'Pause PIE', toolName: 'control_editor', arguments: { action: 'pause' }, expected: 'success - PIE paused' },
-  { scenario: 'Resume PIE', toolName: 'control_editor', arguments: { action: 'resume' }, expected: 'success - PIE resumed' },
-  { scenario: 'Step PIE frame', toolName: 'control_editor', arguments: { action: 'step_frame' }, expected: 'success - frame stepped' },
-  { scenario: 'Create camera bookmark', toolName: 'control_editor', arguments: { action: 'create_bookmark', bookmarkName: 'TC_Bookmark' }, expected: 'success - bookmark created' },
-  { scenario: 'Jump to camera bookmark', toolName: 'control_editor', arguments: { action: 'jump_to_bookmark', bookmarkName: 'TC_Bookmark' }, expected: 'success - jumped to bookmark' },
-  { scenario: 'Set editor preferences', toolName: 'control_editor', arguments: { action: 'set_preferences', category: 'Editor', preferences: { UseGrid: true, SnapToGrid: true } }, expected: 'success - editor preferences set' },
-  // Additional
-  // Real-World Scenario: Editor Automation
-  { scenario: 'Editor Auto - Open Asset', toolName: 'control_editor', arguments: { action: 'open_asset', assetPath: '/Engine/BasicShapes/Cube' }, expected: 'success' },
-  { scenario: 'Editor Auto - Focus Viewport', toolName: 'control_editor', arguments: { action: 'set_camera', location: { x: 500, y: 500, z: 500 }, rotation: { pitch: -30, yaw: 225, roll: 0 } }, expected: 'success' },
-  { scenario: 'Editor Auto - Run Command', toolName: 'control_editor', arguments: { action: 'execute_command', command: 'stat fps' }, expected: 'success' },
-  {
-    scenario: "Error: Invalid view mode",
-    toolName: "control_editor",
-    arguments: { action: "set_view_mode", viewMode: "InvalidMode" },
-    expected: "error|unknown_viewmode"
-  },
-  {
-    scenario: "Edge: Extreme FOV (1 degree)",
-    toolName: "control_editor",
-    arguments: { action: "set_camera_fov", fov: 1 },
-    expected: "success"
-  },
-  {
-    scenario: "Border: Negative speed",
-    toolName: "control_editor",
-    arguments: { action: "set_game_speed", speed: -1 },
-    expected: "success|handled"
-  },
-  {
-    scenario: "Error: Screenshot invalid res",
-    toolName: "control_editor",
-    arguments: { action: "screenshot", resolution: "invalidxres" },
-    expected: "error"
-  },
-  {
-    scenario: "Edge: Empty command",
-    toolName: "control_editor",
-    arguments: { action: "console_command", command: "" },
-    expected: "error|empty"
-  },
-  {
-    scenario: "Timeout short fail",
-    toolName: "control_editor",
-    arguments: { action: "play", timeoutMs: 1 },
-    expected: "timeout|error"
-  }
+
+  // === FRAME STEPPING ===
+  { scenario: 'Step single frame', toolName: 'control_editor', arguments: { action: 'step_frame' }, expected: 'success - frame stepped' },
+  { scenario: 'Step multiple frames', toolName: 'control_editor', arguments: { action: 'step_frame', steps: 5 }, expected: 'success' },
+
+  // === BOOKMARKS ===
+  { scenario: 'Create camera bookmark', toolName: 'control_editor', arguments: { action: 'create_bookmark', bookmarkName: 'TC_Bookmark_1' }, expected: 'success - bookmark created' },
+  { scenario: 'Create second bookmark', toolName: 'control_editor', arguments: { action: 'create_bookmark', bookmarkName: 'TC_Bookmark_2' }, expected: 'success' },
+  { scenario: 'Jump to bookmark 1', toolName: 'control_editor', arguments: { action: 'jump_to_bookmark', bookmarkName: 'TC_Bookmark_1' }, expected: 'success - jumped to bookmark' },
+  { scenario: 'Jump to bookmark 2', toolName: 'control_editor', arguments: { action: 'jump_to_bookmark', bookmarkName: 'TC_Bookmark_2' }, expected: 'success' },
+
+  // === PREFERENCES ===
+  { scenario: 'Set editor preferences - grid', toolName: 'control_editor', arguments: { action: 'set_preferences', category: 'Editor', preferences: { UseGrid: true, SnapToGrid: true } }, expected: 'success - editor preferences set' },
+  { scenario: 'Set editor preferences - realtime', toolName: 'control_editor', arguments: { action: 'set_preferences', category: 'Viewport', preferences: { bRealtimeUpdate: true } }, expected: 'success' },
+
+  // === CONSOLE COMMANDS ===
+  { scenario: 'Execute console command (stat fps)', toolName: 'control_editor', arguments: { action: 'execute_command', command: 'stat fps' }, expected: 'success' },
+  { scenario: 'Console command (alias)', toolName: 'control_editor', arguments: { action: 'console_command', command: 'stat unit' }, expected: 'success' },
+  { scenario: 'Console command - toggle stat', toolName: 'control_editor', arguments: { action: 'console_command', command: 'stat none' }, expected: 'success' },
+
+  // === OPEN ASSET ===
+  { scenario: 'Open asset in editor', toolName: 'control_editor', arguments: { action: 'open_asset', assetPath: '/Engine/BasicShapes/Cube' }, expected: 'success' },
+  { scenario: 'Open material asset', toolName: 'control_editor', arguments: { action: 'open_asset', assetPath: '/Engine/EngineMaterials/DefaultMaterial' }, expected: 'success' },
+
+  // === SIMULATE INPUT ===
+  { scenario: 'Simulate key press W', toolName: 'control_editor', arguments: { action: 'simulate_input', keyName: 'W', eventType: 'KeyDown' }, expected: 'success' },
+  { scenario: 'Simulate key release W', toolName: 'control_editor', arguments: { action: 'simulate_input', keyName: 'W', eventType: 'KeyUp' }, expected: 'success' },
+  { scenario: 'Simulate key press and release Space', toolName: 'control_editor', arguments: { action: 'simulate_input', keyName: 'SpaceBar', eventType: 'Both' }, expected: 'success' },
+
+  // === ERROR CASES ===
+  { scenario: 'Error: Invalid view mode', toolName: 'control_editor', arguments: { action: 'set_view_mode', viewMode: 'InvalidMode' }, expected: 'error|unknown_viewmode' },
+  { scenario: 'Error: Invalid bookmark', toolName: 'control_editor', arguments: { action: 'jump_to_bookmark', bookmarkName: 'NonExistent_Bookmark_XYZ' }, expected: 'error|not_found' },
+  { scenario: 'Error: Empty command', toolName: 'control_editor', arguments: { action: 'console_command', command: '' }, expected: 'error|empty' },
+  { scenario: 'Error: Invalid resolution', toolName: 'control_editor', arguments: { action: 'set_viewport_resolution', width: -100, height: -100 }, expected: 'error|validation' },
+  { scenario: 'Error: Open non-existent asset', toolName: 'control_editor', arguments: { action: 'open_asset', assetPath: '/Game/NonExistent/Asset' }, expected: 'error|not_found' },
+  { scenario: 'Error: Screenshot invalid resolution', toolName: 'control_editor', arguments: { action: 'screenshot', resolution: 'invalidxres' }, expected: 'error' },
+
+  // === EDGE CASES ===
+  { scenario: 'Edge: Extreme FOV (1 degree)', toolName: 'control_editor', arguments: { action: 'set_camera_fov', fov: 1 }, expected: 'success' },
+  { scenario: 'Edge: Negative speed', toolName: 'control_editor', arguments: { action: 'set_game_speed', speed: -1 }, expected: 'success|handled' },
+  { scenario: 'Edge: Zero speed (frozen)', toolName: 'control_editor', arguments: { action: 'set_game_speed', speed: 0 }, expected: 'success' },
+  { scenario: 'Edge: Very high speed', toolName: 'control_editor', arguments: { action: 'set_game_speed', speed: 10.0 }, expected: 'success' },
+
+  // === TIMEOUT TEST ===
+  { scenario: 'Timeout short fail', toolName: 'control_editor', arguments: { action: 'play', timeoutMs: 1 }, expected: 'timeout|error' }
 ];
 
 await runToolTests('Editor Control', testCases);

package/tests/test-graphql.mjs

@@ -150,10 +150,19 @@ async function testGraphQLServer() {
     log.info('You can test it with: curl -X POST -H "Content-Type: application/json" -d \'{"query": "{ assets { edges { node { name path } } } }"\' http://127.0.0.1:4000/graphql');
 
     // Run tests
-    await runGraphQLTests();
-
-    // Keep server running for manual testing
-    log.info('\nGraphQL server is still running. Press Ctrl+C to stop.');
+    const results = await runGraphQLTests();
+
+    // Auto-exit after tests complete
+    log.info('\nTests completed. Shutting down...');
+    await graphQLServer.stop();
+
+    if (results.failed > 0) {
+      log.info(`\n❌ ${results.failed}/${results.total} tests failed`);
+      process.exit(1);
+    } else {
+      log.info(`\n✅ All ${results.passed}/${results.total} tests passed`);
+      process.exit(0);
+    }
   } catch (error) {
     log.error('Failed to start GraphQL server:', error);
     process.exit(1);
@@ -259,6 +268,37 @@ async function runGraphQLTests() {
           }
         }
       `
+    },
+    {
+      name: 'Error Handling - Invalid Query',
+      query: `
+        {
+          invalidField {
+            name
+          }
+        }
+      `,
+      expectError: true
+    },
+    {
+      name: 'Pagination Test',
+      query: `
+        {
+          assets(pagination: { limit: 1, offset: 0 }) {
+            edges {
+              node {
+                name
+              }
+              cursor
+            }
+            pageInfo {
+              hasNextPage
+              hasPreviousPage
+            }
+            totalCount
+          }
+        }
+      `
     }
   ];
 
@@ -278,11 +318,21 @@ async function runGraphQLTests() {
       const result = await response.json();
 
       if (result.errors) {
-        log.error(`  ❌ ${test.name} - GraphQL Errors:`, JSON.stringify(result.errors));
-        failed++;
+        if (test.expectError) {
+          log.info(`  ✅ ${test.name} - Expected error received`);
+          passed++;
+        } else {
+          log.error(`  ❌ ${test.name} - GraphQL Errors:`, JSON.stringify(result.errors));
+          failed++;
+        }
       } else if (result.data) {
-        log.info(`  ✅ ${test.name} - Success`);
-        passed++;
+        if (test.expectError) {
+          log.error(`  ❌ ${test.name} - Expected error but got data`);
+          failed++;
+        } else {
+          log.info(`  ✅ ${test.name} - Success`);
+          passed++;
+        }
       } else {
         log.error(`  ❌ ${test.name} - No data returned`);
         failed++;