@satelliteoflove/godot-mcp 2.16.0 → 2.17.0

package/addon/command_router.gd

@@ -20,6 +20,7 @@ func setup(plugin: EditorPlugin) -> void:
 	_register_handler(MCPResourceCommands.new(), plugin)
 	_register_handler(MCPScene3DCommands.new(), plugin)
 	_register_handler(MCPInputCommands.new(), plugin)
+	_register_handler(MCPProfilerCommands.new(), plugin)
 
 
 func _register_handler(handler: MCPBaseCommand, plugin: EditorPlugin) -> void:

package/addon/commands/debug_commands.gd

@@ -3,21 +3,16 @@ extends MCPBaseCommand
 class_name MCPDebugCommands
 
 const DEBUG_OUTPUT_TIMEOUT := 5.0
-const PERFORMANCE_METRICS_TIMEOUT := 5.0
 
 var _debug_output_result: PackedStringArray = []
 var _debug_output_pending: bool = false
 
-var _performance_metrics_result: Dictionary = {}
-var _performance_metrics_pending: bool = false
-
 
 func get_commands() -> Dictionary:
 	return {
 		"run_project": run_project,
 		"stop_project": stop_project,
 		"get_debug_output": get_debug_output,
-		"get_performance_metrics": get_performance_metrics,
 		"get_log_messages": get_log_messages,
 		"get_errors": get_errors,
 		"get_stack_trace": get_stack_trace,
@@ -100,37 +95,6 @@ func _on_debug_output_received(output: PackedStringArray) -> void:
 	_debug_output_result = output
 
 
-func get_performance_metrics(_params: Dictionary) -> Dictionary:
-	if not EditorInterface.is_playing_scene():
-		return _error("NOT_RUNNING", "No game is currently running")
-
-	var debugger_plugin = _plugin.get_debugger_plugin() if _plugin else null
-	if debugger_plugin == null or not debugger_plugin.has_active_session():
-		return _error("NO_SESSION", "No active debug session")
-
-	_performance_metrics_pending = true
-	_performance_metrics_result = {}
-
-	debugger_plugin.performance_metrics_received.connect(_on_performance_metrics_received, CONNECT_ONE_SHOT)
-	debugger_plugin.request_performance_metrics()
-
-	var start_time := Time.get_ticks_msec()
-	while _performance_metrics_pending:
-		await Engine.get_main_loop().process_frame
-		if (Time.get_ticks_msec() - start_time) / 1000.0 > PERFORMANCE_METRICS_TIMEOUT:
-			_performance_metrics_pending = false
-			if debugger_plugin.performance_metrics_received.is_connected(_on_performance_metrics_received):
-				debugger_plugin.performance_metrics_received.disconnect(_on_performance_metrics_received)
-			return _error("TIMEOUT", "Timed out waiting for performance metrics")
-
-	return _success(_performance_metrics_result)
-
-
-func _on_performance_metrics_received(metrics: Dictionary) -> void:
-	_performance_metrics_pending = false
-	_performance_metrics_result = metrics
-
-
 func get_log_messages(params: Dictionary) -> Dictionary:
 	var clear: bool = params.get("clear", false)
 	var limit: int = params.get("limit", 50)

package/addon/commands/profiler_commands.gd

@@ -0,0 +1,143 @@
+@tool
+extends MCPBaseCommand
+class_name MCPProfilerCommands
+
+const PROFILER_TIMEOUT := 5.0
+const GENERIC_TIMEOUT := 5.0
+
+var _performance_metrics_pending: bool = false
+var _performance_metrics_result: Dictionary = {}
+
+
+func get_commands() -> Dictionary:
+	return {
+		"get_performance_metrics": get_performance_metrics,
+		"start_profiler": start_profiler,
+		"stop_profiler": stop_profiler,
+		"get_profiler_data": get_profiler_data,
+		"get_active_processes": get_active_processes,
+		"get_signal_connections": get_signal_connections,
+	}
+
+
+func get_performance_metrics(_params: Dictionary) -> Dictionary:
+	if not EditorInterface.is_playing_scene():
+		return _error("NOT_RUNNING", "No game is currently running")
+
+	var debugger_plugin = _plugin.get_debugger_plugin() if _plugin else null
+	if debugger_plugin == null or not debugger_plugin.has_active_session():
+		return _error("NO_SESSION", "No active debug session")
+
+	_performance_metrics_pending = true
+	_performance_metrics_result = {}
+
+	debugger_plugin.performance_metrics_received.connect(_on_performance_metrics_received, CONNECT_ONE_SHOT)
+	debugger_plugin.request_performance_metrics()
+
+	var start_time := Time.get_ticks_msec()
+	while _performance_metrics_pending:
+		await Engine.get_main_loop().process_frame
+		if (Time.get_ticks_msec() - start_time) / 1000.0 > PROFILER_TIMEOUT:
+			_performance_metrics_pending = false
+			if debugger_plugin.performance_metrics_received.is_connected(_on_performance_metrics_received):
+				debugger_plugin.performance_metrics_received.disconnect(_on_performance_metrics_received)
+			return _error("TIMEOUT", "Timed out waiting for performance metrics")
+
+	return _success(_performance_metrics_result)
+
+
+func _on_performance_metrics_received(metrics: Dictionary) -> void:
+	_performance_metrics_pending = false
+	_performance_metrics_result = metrics
+
+
+func start_profiler(_params: Dictionary) -> Dictionary:
+	if not EditorInterface.is_playing_scene():
+		return _error("NOT_RUNNING", "No game is currently running")
+
+	var debugger_plugin = _plugin.get_debugger_plugin() if _plugin else null
+	if debugger_plugin == null or not debugger_plugin.has_active_session():
+		return _error("NO_SESSION", "No active debug session")
+
+	debugger_plugin.toggle_frame_profiler(true)
+	return _success({"message": "Frame profiler started"})
+
+
+func stop_profiler(_params: Dictionary) -> Dictionary:
+	if not EditorInterface.is_playing_scene():
+		return _error("NOT_RUNNING", "No game is currently running")
+
+	var debugger_plugin = _plugin.get_debugger_plugin() if _plugin else null
+	if debugger_plugin == null or not debugger_plugin.has_active_session():
+		return _error("NO_SESSION", "No active debug session")
+
+	debugger_plugin.toggle_frame_profiler(false)
+	return _success({"message": "Frame profiler stopped"})
+
+
+func get_profiler_data(_params: Dictionary) -> Dictionary:
+	var result = await _send_and_wait("get_profiler_data")
+	if result == null:
+		return _last_error
+	var result_dict: Dictionary
+	if result is Dictionary:
+		result_dict = result
+	else:
+		result_dict = {"data": result}
+	return _success(result_dict)
+
+
+func get_active_processes(_params: Dictionary) -> Dictionary:
+	var result = await _send_and_wait("get_active_processes")
+	if result == null:
+		return _last_error
+	var result_dict: Dictionary
+	if result is Dictionary:
+		result_dict = result
+	else:
+		result_dict = {"data": result}
+	return _success(result_dict)
+
+
+func get_signal_connections(params: Dictionary) -> Dictionary:
+	var node_path: String = params.get("node_path", "")
+	var result = await _send_and_wait("get_signal_connections", [node_path])
+	if result == null:
+		return _last_error
+	var result_dict: Dictionary
+	if result is Dictionary:
+		result_dict = result
+	else:
+		result_dict = {"data": result}
+	return _success(result_dict)
+
+
+var _last_error: Dictionary = {}
+
+
+func _send_and_wait(msg_type: String, args: Array = []):
+	if not EditorInterface.is_playing_scene():
+		_last_error = _error("NOT_RUNNING", "No game is currently running")
+		return null
+
+	var debugger_plugin = _plugin.get_debugger_plugin() if _plugin else null
+	if debugger_plugin == null or not debugger_plugin.has_active_session():
+		_last_error = _error("NO_SESSION", "No active debug session")
+		return null
+
+	var sent: bool = debugger_plugin.send_game_message(msg_type, args)
+	if not sent:
+		_last_error = _error("SEND_FAILED", "Failed to send message to game")
+		return null
+
+	var start_time := Time.get_ticks_msec()
+	while not debugger_plugin.has_response(msg_type):
+		await Engine.get_main_loop().process_frame
+		if (Time.get_ticks_msec() - start_time) / 1000.0 > GENERIC_TIMEOUT:
+			debugger_plugin.clear_response(msg_type)
+			_last_error = _error("TIMEOUT", "Timed out waiting for %s response" % msg_type)
+			return null
+
+	var response = debugger_plugin.get_response(msg_type)
+	debugger_plugin.clear_response(msg_type)
+	return response

package/addon/core/mcp_debugger_plugin.gd

@@ -9,6 +9,7 @@ signal find_nodes_received(matches: Array, count: int, error: String)
 signal input_map_received(actions: Array, error: String)
 signal input_sequence_completed(result: Dictionary)
 signal type_text_completed(result: Dictionary)
+signal game_response(message_type: String, data: Variant)
 
 var _active_session_id: int = -1
 var _pending_screenshot: bool = false
@@ -18,6 +19,8 @@ var _pending_find_nodes: bool = false
 var _pending_input_map: bool = false
 var _pending_input_sequence: bool = false
 var _pending_type_text: bool = false
+var _pending_requests: Dictionary = {}
+var _responses: Dictionary = {}
 
 
 func _has_capture(prefix: String) -> bool:
@@ -47,6 +50,9 @@ func _capture(message: String, data: Array, session_id: int) -> bool:
 		"godot_mcp:type_text_result":
 			_handle_type_text_result(data)
 			return true
+		"godot_mcp:game_response":
+			_handle_game_response(data)
+			return true
 	return false
 
 
@@ -77,6 +83,9 @@ func _session_stopped() -> void:
 	if _pending_type_text:
 		_pending_type_text = false
 		type_text_completed.emit({"error": "Game session ended"})
+	for msg_type in _pending_requests:
+		_responses[msg_type] = {}
+	_pending_requests.clear()
 
 
 func has_active_session() -> bool:
@@ -229,3 +238,46 @@ func _handle_type_text_result(data: Array) -> void:
 	_pending_type_text = false
 	var result: Dictionary = data[0] if data.size() > 0 else {}
 	type_text_completed.emit(result)
+
+
+func send_game_message(msg_type: String, args: Array = []) -> bool:
+	if _active_session_id < 0:
+		return false
+	var session := get_session(_active_session_id)
+	if not session:
+		return false
+	_pending_requests[msg_type] = true
+	_responses.erase(msg_type)
+	session.send_message("godot_mcp:" + msg_type, args)
+	return true
+
+
+func has_response(msg_type: String) -> bool:
+	return _responses.has(msg_type)
+
+
+func get_response(msg_type: String) -> Variant:
+	return _responses.get(msg_type)
+
+
+func clear_response(msg_type: String) -> void:
+	_responses.erase(msg_type)
+	_pending_requests.erase(msg_type)
+
+
+func _handle_game_response(data: Array) -> void:
+	if data.size() < 2:
+		return
+	var msg_type: String = data[0]
+	var response_data: Variant = data[1]
+	_pending_requests.erase(msg_type)
+	_responses[msg_type] = response_data
+	game_response.emit(msg_type, response_data)
+
+
+func toggle_frame_profiler(enable: bool) -> void:
+	if _active_session_id < 0:
+		return
+	var session := get_session(_active_session_id)
+	if session:
+		session.toggle_profiler("mcp_frame_profiler", enable)

package/addon/game_bridge/mcp_frame_profiler.gd

@@ -0,0 +1,61 @@
+extends EngineProfiler
+class_name MCPFrameProfiler
+
+const MAX_FRAMES := 300
+const MONITOR_SAMPLE_INTERVAL := 10
+
+var _active := false
+var _buffer: Array[Dictionary] = []
+var _frame_index := 0
+
+
+func _toggle(enable: bool, _options: Array) -> void:
+	_active = enable
+	if enable:
+		_buffer.clear()
+		_frame_index = 0
+
+
+func _tick(frame_time: float, process_time: float, physics_time: float, physics_frame_time: float) -> void:
+	if not _active:
+		return
+
+	var entry := {
+		"ft": frame_time,
+		"pt": process_time,
+		"pht": physics_time,
+		"pft": physics_frame_time,
+		"i": _frame_index,
+	}
+
+	if _frame_index % MONITOR_SAMPLE_INTERVAL == 0:
+		entry["m"] = _snapshot_monitors()
+
+	_buffer.append(entry)
+	if _buffer.size() > MAX_FRAMES:
+		_buffer.pop_front()
+
+	_frame_index += 1
+
+
+func get_buffer_data() -> Dictionary:
+	return {
+		"active": _active,
+		"frame_count": _buffer.size(),
+		"total_frames_collected": _frame_index,
+		"max_fps": Engine.max_fps,
+		"frames": _buffer.duplicate(),
+	}
+
+
+func _snapshot_monitors() -> Dictionary:
+	return {
+		"fps": Performance.get_monitor(Performance.TIME_FPS),
+		"obj_count": int(Performance.get_monitor(Performance.OBJECT_COUNT)),
+		"node_count": int(Performance.get_monitor(Performance.OBJECT_NODE_COUNT)),
+		"orphan_nodes": int(Performance.get_monitor(Performance.OBJECT_ORPHAN_NODE_COUNT)),
+		"mem_static": int(Performance.get_monitor(Performance.MEMORY_STATIC)),
+		"render_objects": int(Performance.get_monitor(Performance.RENDER_TOTAL_OBJECTS_IN_FRAME)),
+		"render_draw_calls": int(Performance.get_monitor(Performance.RENDER_TOTAL_DRAW_CALLS_IN_FRAME)),
+		"render_primitives": int(Performance.get_monitor(Performance.RENDER_TOTAL_PRIMITIVES_IN_FRAME)),
+	}

package/addon/game_bridge/mcp_game_bridge.gd

@@ -4,6 +4,7 @@ class_name MCPGameBridge
 const DEFAULT_MAX_WIDTH := 1920
 
 var _logger: _MCPGameLogger
+var _profiler: MCPFrameProfiler
 
 
 func _ready() -> void:
@@ -11,6 +12,8 @@ func _ready() -> void:
 		return
 	_logger = _MCPGameLogger.new()
 	OS.add_logger(_logger)
+	_profiler = MCPFrameProfiler.new()
+	EngineDebugger.register_profiler("mcp_frame_profiler", _profiler)
 	EngineDebugger.register_message_capture("godot_mcp", _on_debugger_message)
 	MCPLog.info("Game bridge initialized")
 
@@ -18,6 +21,8 @@ func _ready() -> void:
 func _exit_tree() -> void:
 	if EngineDebugger.is_active():
 		EngineDebugger.unregister_message_capture("godot_mcp")
+		if _profiler:
+			EngineDebugger.unregister_profiler("mcp_frame_profiler")
 
 
 func _process(_delta: float) -> void:
@@ -75,6 +80,15 @@ func _on_debugger_message(message: String, data: Array) -> bool:
 		"type_text":
 			_handle_type_text(data)
 			return true
+		"get_profiler_data":
+			_handle_get_profiler_data()
+			return true
+		"get_active_processes":
+			_handle_get_active_processes()
+			return true
+		"get_signal_connections":
+			_handle_get_signal_connections(data)
+			return true
 	return false
 
 
@@ -191,19 +205,175 @@ func _handle_get_performance_metrics() -> void:
 		"render_objects": int(Performance.get_monitor(Performance.RENDER_TOTAL_OBJECTS_IN_FRAME)),
 		"render_draw_calls": int(Performance.get_monitor(Performance.RENDER_TOTAL_DRAW_CALLS_IN_FRAME)),
 		"render_primitives": int(Performance.get_monitor(Performance.RENDER_TOTAL_PRIMITIVES_IN_FRAME)),
+		"render_video_mem": int(Performance.get_monitor(Performance.RENDER_VIDEO_MEM_USED)),
+		"render_texture_mem": int(Performance.get_monitor(Performance.RENDER_TEXTURE_MEM_USED)),
+		"render_buffer_mem": int(Performance.get_monitor(Performance.RENDER_BUFFER_MEM_USED)),
 		"physics_2d_active_objects": int(Performance.get_monitor(Performance.PHYSICS_2D_ACTIVE_OBJECTS)),
 		"physics_2d_collision_pairs": int(Performance.get_monitor(Performance.PHYSICS_2D_COLLISION_PAIRS)),
 		"physics_2d_island_count": int(Performance.get_monitor(Performance.PHYSICS_2D_ISLAND_COUNT)),
+		"physics_3d_active_objects": int(Performance.get_monitor(Performance.PHYSICS_3D_ACTIVE_OBJECTS)),
+		"physics_3d_collision_pairs": int(Performance.get_monitor(Performance.PHYSICS_3D_COLLISION_PAIRS)),
+		"physics_3d_island_count": int(Performance.get_monitor(Performance.PHYSICS_3D_ISLAND_COUNT)),
+		"audio_output_latency": Performance.get_monitor(Performance.AUDIO_OUTPUT_LATENCY),
 		"object_count": int(Performance.get_monitor(Performance.OBJECT_COUNT)),
 		"object_resource_count": int(Performance.get_monitor(Performance.OBJECT_RESOURCE_COUNT)),
 		"object_node_count": int(Performance.get_monitor(Performance.OBJECT_NODE_COUNT)),
 		"object_orphan_node_count": int(Performance.get_monitor(Performance.OBJECT_ORPHAN_NODE_COUNT)),
 		"memory_static": int(Performance.get_monitor(Performance.MEMORY_STATIC)),
 		"memory_static_max": int(Performance.get_monitor(Performance.MEMORY_STATIC_MAX)),
+		"memory_msg_buffer_max": int(Performance.get_monitor(Performance.MEMORY_MESSAGE_BUFFER_MAX)),
+		"navigation_active_maps": int(Performance.get_monitor(Performance.NAVIGATION_ACTIVE_MAPS)),
+		"navigation_region_count": int(Performance.get_monitor(Performance.NAVIGATION_REGION_COUNT)),
+		"navigation_agent_count": int(Performance.get_monitor(Performance.NAVIGATION_AGENT_COUNT)),
+		"navigation_link_count": int(Performance.get_monitor(Performance.NAVIGATION_LINK_COUNT)),
+		"navigation_polygon_count": int(Performance.get_monitor(Performance.NAVIGATION_POLYGON_COUNT)),
+		"navigation_edge_count": int(Performance.get_monitor(Performance.NAVIGATION_EDGE_COUNT)),
+		"navigation_edge_merge_count": int(Performance.get_monitor(Performance.NAVIGATION_EDGE_MERGE_COUNT)),
+		"navigation_edge_connection_count": int(Performance.get_monitor(Performance.NAVIGATION_EDGE_CONNECTION_COUNT)),
+		"navigation_edge_free_count": int(Performance.get_monitor(Performance.NAVIGATION_EDGE_FREE_COUNT)),
+		"navigation_obstacle_count": int(Performance.get_monitor(Performance.NAVIGATION_OBSTACLE_COUNT)),
+		"pipeline_compilations_canvas": int(Performance.get_monitor(Performance.PIPELINE_COMPILATIONS_CANVAS)),
+		"pipeline_compilations_mesh": int(Performance.get_monitor(Performance.PIPELINE_COMPILATIONS_MESH)),
+		"pipeline_compilations_surface": int(Performance.get_monitor(Performance.PIPELINE_COMPILATIONS_SURFACE)),
+		"pipeline_compilations_draw": int(Performance.get_monitor(Performance.PIPELINE_COMPILATIONS_DRAW)),
+		"pipeline_compilations_specialization": int(Performance.get_monitor(Performance.PIPELINE_COMPILATIONS_SPECIALIZATION)),
 	}
+
+	var rid := get_viewport().get_viewport_rid()
+	metrics["viewport_render_cpu_ms"] = RenderingServer.viewport_get_measured_render_time_cpu(rid) + RenderingServer.viewport_get_measured_render_time_gpu(rid)
+	metrics["viewport_render_gpu_ms"] = RenderingServer.viewport_get_measured_render_time_gpu(rid)
+
 	EngineDebugger.send_message("godot_mcp:performance_metrics_result", [metrics])
 
 
+func _handle_get_profiler_data() -> void:
+	var data := _profiler.get_buffer_data() if _profiler else {}
+	EngineDebugger.send_message("godot_mcp:game_response", ["get_profiler_data", data])
+
+
+func _handle_get_active_processes() -> void:
+	var tree := get_tree()
+	var scene_root := tree.current_scene if tree else null
+	if not scene_root:
+		EngineDebugger.send_message("godot_mcp:game_response", ["get_active_processes", {"processes": []}])
+		return
+
+	var script_map: Dictionary = {}
+	_collect_processes(scene_root, scene_root, script_map)
+
+	var processes: Array = []
+	for script_path in script_map:
+		processes.append(script_map[script_path])
+
+	processes.sort_custom(func(a: Dictionary, b: Dictionary) -> bool:
+		return a.instance_count > b.instance_count
+	)
+
+	EngineDebugger.send_message("godot_mcp:game_response", ["get_active_processes", {"processes": processes}])
+
+
+func _collect_processes(node: Node, scene_root: Node, script_map: Dictionary) -> void:
+	var is_proc := node.is_processing()
+	var is_phys := node.is_physics_processing()
+
+	if is_proc or is_phys:
+		var script_path := ""
+		var script := node.get_script()
+		if script and script is Script:
+			script_path = script.resource_path
+		if script_path.is_empty():
+			script_path = node.get_class()
+
+		if not script_map.has(script_path):
+			script_map[script_path] = {
+				"script_path": script_path,
+				"has_process": false,
+				"has_physics_process": false,
+				"instance_count": 0,
+				"example_paths": [],
+			}
+
+		var entry: Dictionary = script_map[script_path]
+		if is_proc:
+			entry.has_process = true
+		if is_phys:
+			entry.has_physics_process = true
+		entry.instance_count += 1
+		if entry.example_paths.size() < 3:
+			var path := "/root/" + scene_root.name
+			var relative := scene_root.get_path_to(node)
+			if relative != NodePath("."):
+				path += "/" + str(relative)
+			entry.example_paths.append(path)
+
+	for child in node.get_children():
+		_collect_processes(child, scene_root, script_map)
+
+
+func _handle_get_signal_connections(data: Array) -> void:
+	var node_path: String = data[0] if data.size() > 0 else ""
+
+	var tree := get_tree()
+	var scene_root := tree.current_scene if tree else null
+	if not scene_root:
+		EngineDebugger.send_message("godot_mcp:game_response", ["get_signal_connections", {"connections": []}])
+		return
+
+	var search_root: Node = scene_root
+	if not node_path.is_empty():
+		search_root = _get_node_from_path(node_path, scene_root)
+		if not search_root:
+			EngineDebugger.send_message("godot_mcp:game_response", ["get_signal_connections", {"connections": [], "error": "Node not found: " + node_path}])
+			return
+
+	var connections: Array = []
+	_collect_signal_connections(search_root, scene_root, connections, 0)
+
+	EngineDebugger.send_message("godot_mcp:game_response", ["get_signal_connections", {"connections": connections}])
+
+
+const MAX_SIGNAL_CONNECTIONS := 200
+const MAX_SIGNAL_DEPTH := 20
+
+
+func _collect_signal_connections(node: Node, scene_root: Node, connections: Array, depth: int) -> void:
+	if connections.size() >= MAX_SIGNAL_CONNECTIONS or depth > MAX_SIGNAL_DEPTH:
+		return
+
+	var source_path := _node_path_string(node, scene_root)
+
+	for sig_info in node.get_signal_list():
+		var sig_name: String = sig_info.name
+		for conn in node.get_signal_connection_list(sig_name):
+			if connections.size() >= MAX_SIGNAL_CONNECTIONS:
+				return
+			var target: Object = conn.callable.get_object()
+			var target_path := ""
+			if target is Node:
+				target_path = _node_path_string(target as Node, scene_root)
+			else:
+				target_path = str(target)
+			connections.append({
+				"source_path": source_path,
+				"signal_name": sig_name,
+				"target_path": target_path,
+				"method_name": conn.callable.get_method(),
+			})
+
+	for child in node.get_children():
+		if connections.size() >= MAX_SIGNAL_CONNECTIONS:
+			return
+		_collect_signal_connections(child, scene_root, connections, depth + 1)
+
+
+func _node_path_string(node: Node, scene_root: Node) -> String:
+	var path := "/root/" + scene_root.name
+	var relative := scene_root.get_path_to(node)
+	if relative != NodePath("."):
+		path += "/" + str(relative)
+	return path
+
+
 class _MCPGameLogger extends Logger:
 	var _output: PackedStringArray = []
 	var _max_lines := 1000

package/addon/plugin.cfg

@@ -3,6 +3,6 @@
 name="Godot MCP"
 description="Model Context Protocol server for AI assistant integration"
 author="godot-mcp"
-version="2.16.0"
+version="2.17.0"
 script="plugin.gd"
 godot_version_min="4.5"