@baixfeng/godot-mcp-cli 1.0.11

package/addons/godot_mcp/mcp_server.gd

@@ -0,0 +1,260 @@
+@tool
+extends EditorPlugin
+
+var websocket_server: MCPWebSocketServer
+var command_handler = null  # Command handler reference
+var panel = null  # Reference to the MCP panel
+var runtime_debugger_bridge = null  # Runtime scene inspection bridge
+var debugger_bridge = null  # Debugger control bridge
+var debug_output_publisher = null  # Live debug output broadcaster
+var _runtime_bridge_warning_logged := false
+var _debugger_bridge_warning_logged := false
+const SCENE_CAPTURE_NAMES := ["scene", "limboai", "mcp_eval", "mcp_input"]
+const STACK_CAPTURE_NAMES := ["stack", "call_stack", "callstack"]
+
+const INPUT_HANDLER_AUTOLOAD_NAME := "MCPInputHandler"
+const INPUT_HANDLER_SCRIPT_PATH := "res://addons/godot_mcp/mcp_input_handler.gd"
+
+func _enter_tree():
+	# Store plugin instance for EditorInterface access
+	Engine.set_meta("GodotMCPPlugin", self)
+	_runtime_bridge_warning_logged = false
+	_debugger_bridge_warning_logged = false
+	_try_register_runtime_bridge()
+	_try_register_debugger_bridge()
+	_register_input_handler_autoload()
+
+	print("\n=== MCP SERVER STARTING ===")
+
+	# Initialize the websocket server
+	websocket_server = load("res://addons/godot_mcp/websocket_server.gd").new()
+	websocket_server.name = "WebSocketServer"
+	add_child(websocket_server)
+	websocket_server.connect("client_disconnected", Callable(self, "_on_client_disconnected"))
+
+	# Initialize the command handler
+	print("Creating command handler...")
+	var handler_script = load("res://addons/godot_mcp/command_handler.gd")
+	if handler_script:
+		command_handler = Node.new()
+		command_handler.set_script(handler_script)
+		command_handler.name = "CommandHandler"
+		websocket_server.add_child(command_handler)
+
+		# Connect signals
+		print("Connecting command handler signals...")
+		websocket_server.connect("command_received", Callable(command_handler, "_handle_command"))
+	else:
+		printerr("Failed to load command handler script!")
+
+	# Initialize the control panel
+	panel = load("res://addons/godot_mcp/ui/mcp_panel.tscn").instantiate()
+	panel.websocket_server = websocket_server
+	add_control_to_bottom_panel(panel, "MCP Server")
+
+	# Initialize live debug output publisher
+	var publisher_script = load("res://addons/godot_mcp/mcp_debug_output_publisher.gd")
+	if publisher_script:
+		debug_output_publisher = publisher_script.new()
+		debug_output_publisher.name = "DebugOutputPublisher"
+		debug_output_publisher.websocket_server = websocket_server
+		add_child(debug_output_publisher)
+		Engine.set_meta("MCPDebugOutputPublisher", debug_output_publisher)
+
+	print("MCP Server plugin initialized")
+	# Server startup will be handled in _ready() with proper timing
+
+func _ready():
+	# Wait for Godot to fully initialize before starting the server
+	_start_server_with_improved_timing()
+
+func _start_server_with_improved_timing(attempt: int = 0):
+	# Wait for full Godot initialization (double frame wait)
+	await get_tree().process_frame
+	await get_tree().process_frame
+
+	print("Attempting to start MCP WebSocket server...")
+	var start_result := websocket_server.start_server()
+
+	if start_result == OK:
+		print("✓ MCP WebSocket server started successfully")
+		# Verify server is actually ready
+		await get_tree().create_timer(0.5).timeout
+		if websocket_server.is_server_active():
+			print("✓ MCP WebSocket server verified and ready")
+		else:
+			print("⚠ MCP server started but not fully active, may need manual start")
+	elif start_result == ERR_ALREADY_IN_USE:
+		print("✓ MCP WebSocket server already running")
+	else:
+		if attempt < 3:  # Retry up to 3 times
+			print("✗ MCP server start failed (code: %d), retrying in 1 second... (attempt %d/3)" % [start_result, attempt + 1])
+			await get_tree().create_timer(1.0).timeout
+			_start_server_with_improved_timing(attempt + 1)
+		else:
+			printerr("✗ Failed to start MCP server after 3 attempts (final code: %d)" % start_result)
+			printerr("Please use the 'Start' button in the MCP Server panel at the bottom of the editor")
+
+func _exit_tree():
+	# Remove plugin instance from Engine metadata
+	if Engine.has_meta("GodotMCPPlugin"):
+		Engine.remove_meta("GodotMCPPlugin")
+	if Engine.has_meta("MCPRuntimeDebuggerBridge"):
+		Engine.remove_meta("MCPRuntimeDebuggerBridge")
+	if Engine.has_meta("MCPDebuggerBridge"):
+		Engine.remove_meta("MCPDebuggerBridge")
+	if Engine.has_meta("MCPDebugOutputPublisher"):
+		Engine.remove_meta("MCPDebugOutputPublisher")
+	_update_debugger_captures(false)
+	_remove_input_handler_autoload()
+
+	if runtime_debugger_bridge:
+		remove_debugger_plugin(runtime_debugger_bridge)
+		runtime_debugger_bridge = null
+
+	if debugger_bridge:
+		remove_debugger_plugin(debugger_bridge)
+		debugger_bridge = null
+
+	# Clean up the panel
+	if panel:
+		remove_control_from_bottom_panel(panel)
+		panel.queue_free()
+		panel = null
+
+	if debug_output_publisher:
+		debug_output_publisher.unsubscribe_all()
+		debug_output_publisher.queue_free()
+		debug_output_publisher = null
+
+	# Clean up the websocket server and command handler
+	if websocket_server:
+		websocket_server.stop_server()
+		websocket_server.queue_free()
+		websocket_server = null
+
+	print("=== MCP SERVER SHUTDOWN ===")
+
+# Method to get the debugger bridge for other components
+func get_debugger_bridge():
+	return debugger_bridge
+
+# Helper function for command processors to access EditorInterface
+func get_editor_interface():
+	return super.get_editor_interface()
+
+# Helper function for command processors to get undo/redo manager
+func get_undo_redo():
+	return super.get_undo_redo()
+
+func _try_register_runtime_bridge() -> bool:
+	if runtime_debugger_bridge:
+		return true
+
+	var runtime_bridge_script = load("res://addons/godot_mcp/mcp_runtime_debugger_bridge.gd")
+	if not runtime_bridge_script:
+		if not _runtime_bridge_warning_logged:
+			_runtime_bridge_warning_logged = true
+			print("Godot MCP runtime scene inspection unavailable (bridge script not found).")
+		return false
+
+	if not ClassDB.class_exists("EditorDebuggerPlugin"):
+		if not _runtime_bridge_warning_logged:
+			_runtime_bridge_warning_logged = true
+			print("Godot MCP runtime scene inspection unavailable on this editor version.")
+		return false
+
+	var runtime_bridge_instance = runtime_bridge_script.new()
+	if runtime_bridge_instance == null:
+		if not _runtime_bridge_warning_logged:
+			_runtime_bridge_warning_logged = true
+			print("Godot MCP runtime scene inspection disabled (bridge instantiation failed).")
+		return false
+
+	runtime_debugger_bridge = runtime_bridge_instance
+	add_debugger_plugin(runtime_debugger_bridge)
+	Engine.set_meta("MCPRuntimeDebuggerBridge", runtime_debugger_bridge)
+	_update_debugger_captures(true)
+	_runtime_bridge_warning_logged = false
+	print("Godot MCP runtime scene inspection enabled.")
+	return true
+
+func _try_register_debugger_bridge() -> bool:
+	if debugger_bridge:
+		return true
+
+	var debugger_bridge_script = load("res://addons/godot_mcp/mcp_debugger_bridge.gd")
+	if not debugger_bridge_script:
+		if not _debugger_bridge_warning_logged:
+			_debugger_bridge_warning_logged = true
+			print("Godot MCP debugger bridge unavailable (bridge script not found).")
+		return false
+
+	if not ClassDB.class_exists("EditorDebuggerPlugin"):
+		if not _debugger_bridge_warning_logged:
+			_debugger_bridge_warning_logged = true
+			print("Godot MCP debugger bridge unavailable on this editor version.")
+		return false
+
+	var debugger_bridge_instance = debugger_bridge_script.new()
+	if debugger_bridge_instance == null:
+		if not _debugger_bridge_warning_logged:
+			_debugger_bridge_warning_logged = true
+			print("Godot MCP debugger bridge disabled (bridge instantiation failed).")
+		return false
+
+	debugger_bridge = debugger_bridge_instance
+	add_debugger_plugin(debugger_bridge)
+	Engine.set_meta("MCPDebuggerBridge", debugger_bridge)
+	_debugger_bridge_warning_logged = false
+	print("Godot MCP debugger bridge enabled.")
+	return true
+
+func _update_debugger_captures(enable: bool) -> void:
+	if not Engine.has_singleton("EngineDebugger"):
+		return
+	var engine_debugger = Engine.get_singleton("EngineDebugger")
+	if engine_debugger == null:
+		return
+	if not engine_debugger.has_method("set_capture"):
+		return
+	var has_query := engine_debugger.has_method("has_capture")
+	for name in SCENE_CAPTURE_NAMES + STACK_CAPTURE_NAMES:
+		if enable:
+			if not has_query or not engine_debugger.has_capture(name):
+				engine_debugger.set_capture(name, true)
+		else:
+			if not has_query or engine_debugger.has_capture(name):
+				engine_debugger.set_capture(name, false)
+
+func _on_client_disconnected(client_id: int) -> void:
+	if debug_output_publisher:
+		debug_output_publisher.unsubscribe(client_id)
+
+
+func _register_input_handler_autoload() -> void:
+	# Check if autoload already exists
+	if ProjectSettings.has_setting("autoload/" + INPUT_HANDLER_AUTOLOAD_NAME):
+		print("MCP Input Handler autoload already registered.")
+		return
+	
+	# Verify the script exists
+	if not FileAccess.file_exists(INPUT_HANDLER_SCRIPT_PATH):
+		printerr("MCP Input Handler script not found at: " + INPUT_HANDLER_SCRIPT_PATH)
+		return
+	
+	# Add the autoload
+	ProjectSettings.set_setting("autoload/" + INPUT_HANDLER_AUTOLOAD_NAME, "*" + INPUT_HANDLER_SCRIPT_PATH)
+	ProjectSettings.save()
+	print("MCP Input Handler autoload registered. Restart the game for input simulation to work.")
+
+
+func _remove_input_handler_autoload() -> void:
+	# Check if autoload exists before removing
+	if not ProjectSettings.has_setting("autoload/" + INPUT_HANDLER_AUTOLOAD_NAME):
+		return
+	
+	# Remove the autoload
+	ProjectSettings.set_setting("autoload/" + INPUT_HANDLER_AUTOLOAD_NAME, null)
+	ProjectSettings.save()
+	print("MCP Input Handler autoload removed.")

package/addons/godot_mcp/mcp_server.gd.uid

@@ -0,0 +1 @@
+uid://wqy34yy6d1kr

package/addons/godot_mcp/plugin.cfg

@@ -0,0 +1,7 @@
+[plugin]
+
+name="Godot MCP"
+description="Godot integration with Claude AI via the Model Context Protocol"
+author="Your Name"
+version="1.0.0"
+script="mcp_server.gd"

package/addons/godot_mcp/runtime_debugger.gd

@@ -0,0 +1,81 @@
+extends RefCounted
+
+# Runtime debugger helper that provides bridge functionality
+# This is not a runtime script anymore, but a helper for the debugger bridge
+
+const DEBUGGER_CAPTURE_NAME := "mcp_debugger"
+
+class RuntimeBreakpointManager:
+	var _breakpoints: Dictionary = {}
+	var _engine_debugger = null
+
+	func _init():
+		_engine_debugger = Engine.get_singleton("EngineDebugger")
+		if _engine_debugger:
+			print("[MCP Runtime Debugger] EngineDebugger singleton available")
+
+	# Add a breakpoint to be tracked
+	func add_breakpoint(script_path: String, line: int) -> bool:
+		var key = "%s:%d" % [script_path, line]
+		if not _breakpoints.has(script_path):
+			_breakpoints[script_path] = []
+
+		if line not in _breakpoints[script_path]:
+			_breakpoints[script_path].append(line)
+			print("[MCP Runtime Debugger] Tracking breakpoint: %s" % key)
+			return true
+		return false
+
+	# Remove a breakpoint from tracking
+	func remove_breakpoint(script_path: String, line: int) -> bool:
+		if _breakpoints.has(script_path):
+			if line in _breakpoints[script_path]:
+				_breakpoints[script_path].erase(line)
+				print("[MCP Runtime Debugger] Removed breakpoint: %s:%d" % [script_path, line])
+				if _breakpoints[script_path].is_empty():
+					_breakpoints.erase(script_path)
+				return true
+		return false
+
+	# Get all tracked breakpoints
+	func get_breakpoints() -> Dictionary:
+		return _breakpoints.duplicate(true)
+
+	# Clear all breakpoints
+	func clear_breakpoints() -> void:
+		_breakpoints.clear()
+		print("[MCP Runtime Debugger] All breakpoints cleared")
+
+	# Check if a breakpoint exists at the given location
+	func has_breakpoint(script_path: String, line: int) -> bool:
+		return _breakpoints.has(script_path) and line in _breakpoints[script_path]
+
+# Static instance for global access
+static var _instance: RuntimeBreakpointManager = null
+
+static func get_instance() -> RuntimeBreakpointManager:
+	if _instance == null:
+		_instance = RuntimeBreakpointManager.new()
+	return _instance
+
+# Helper functions for the debugger bridge
+static func register_breakpoint(script_path: String, line: int) -> bool:
+	var instance = get_instance()
+	return instance.add_breakpoint(script_path, line)
+
+static func unregister_breakpoint(script_path: String, line: int) -> bool:
+	var instance = get_instance()
+	return instance.remove_breakpoint(script_path, line)
+
+static func get_all_breakpoints() -> Dictionary:
+	var instance = get_instance()
+	return instance.get_breakpoints()
+
+static func clear_all_breakpoints() -> void:
+	var instance = get_instance()
+	instance.clear_breakpoints()
+
+static func is_breakpoint_active(script_path: String, line: int) -> bool:
+	var instance = get_instance()
+	return instance.has_breakpoint(script_path, line)
+

package/addons/godot_mcp/runtime_debugger.gd.uid

@@ -0,0 +1 @@
+uid://bt44g1v3ce6nb

package/addons/godot_mcp/ui/mcp_panel.gd

@@ -0,0 +1,94 @@
+@tool
+extends Control
+
+var websocket_server: MCPWebSocketServer
+var status_label: Label
+var port_input: SpinBox
+var start_button: Button
+var stop_button: Button
+var connection_count_label: Label
+var log_text: TextEdit
+
+func _ready():
+	status_label = $VBoxContainer/StatusContainer/StatusLabel
+	port_input = $VBoxContainer/PortContainer/PortSpinBox
+	start_button = $VBoxContainer/ButtonsContainer/StartButton
+	stop_button = $VBoxContainer/ButtonsContainer/StopButton
+	connection_count_label = $VBoxContainer/ConnectionsContainer/CountLabel
+	log_text = $VBoxContainer/LogContainer/LogText
+	
+	start_button.pressed.connect(_on_start_button_pressed)
+	stop_button.pressed.connect(_on_stop_button_pressed)
+	port_input.value_changed.connect(_on_port_changed)
+	
+	# Initial UI setup
+	_update_ui()
+	
+	# Setup server signals once it's available
+	await get_tree().process_frame
+	if websocket_server:
+		websocket_server.connect("client_connected", Callable(self, "_on_client_connected"))
+		websocket_server.connect("client_disconnected", Callable(self, "_on_client_disconnected"))
+		websocket_server.connect("command_received", Callable(self, "_on_command_received"))
+		
+		port_input.value = websocket_server.get_port()
+
+func _update_ui():
+	if not websocket_server:
+		status_label.text = "Server: Not initialized"
+		start_button.disabled = true
+		stop_button.disabled = true
+		port_input.editable = true
+		connection_count_label.text = "0"
+		return
+	
+	var is_active = websocket_server.is_server_active()
+	
+	status_label.text = "Server: " + ("Running" if is_active else "Stopped")
+	start_button.disabled = is_active
+	stop_button.disabled = not is_active
+	port_input.editable = not is_active
+	
+	if is_active:
+		connection_count_label.text = str(websocket_server.get_client_count())
+	else:
+		connection_count_label.text = "0"
+
+func _on_start_button_pressed():
+	if websocket_server:
+		var result = websocket_server.start_server()
+		if result == OK:
+			_log_message("Server started on port " + str(websocket_server.get_port()))
+		else:
+			_log_message("Failed to start server: " + str(result))
+		_update_ui()
+
+func _on_stop_button_pressed():
+	if websocket_server:
+		websocket_server.stop_server()
+		_log_message("Server stopped")
+		_update_ui()
+
+func _on_port_changed(new_port: float):
+	if websocket_server:
+		websocket_server.set_port(int(new_port))
+		_log_message("Port changed to " + str(int(new_port)))
+
+func _on_client_connected(client_id: int):
+	_log_message("Client connected: " + str(client_id))
+	_update_ui()
+
+func _on_client_disconnected(client_id: int):
+	_log_message("Client disconnected: " + str(client_id))
+	_update_ui()
+
+func _on_command_received(client_id: int, command: Dictionary):
+	var command_type = command.get("type", "unknown")
+	var command_id = command.get("commandId", "no-id")
+	_log_message("Received command: " + command_type + " (ID: " + command_id + ") from client " + str(client_id))
+
+func _log_message(message: String):
+	var timestamp = Time.get_datetime_string_from_system()
+	log_text.text += "[" + timestamp + "] " + message + "\n"
+	# Auto-scroll to bottom
+	log_text.scroll_vertical = log_text.get_line_count()

package/addons/godot_mcp/ui/mcp_panel.gd.uid

@@ -0,0 +1 @@
+uid://d2c1roi0jmke1

package/addons/godot_mcp/ui/mcp_panel.tscn

@@ -0,0 +1,96 @@
+[gd_scene load_steps=2 format=3 uid="uid://c2kuk5yuiage8"]
+
+[ext_resource type="Script" path="res://addons/godot_mcp/ui/mcp_panel.gd" id="1_3cbiu"]
+
+[node name="MCPPanel" type="Control"]
+layout_mode = 3
+anchors_preset = 15
+anchor_right = 1.0
+anchor_bottom = 1.0
+grow_horizontal = 2
+grow_vertical = 2
+script = ExtResource("1_3cbiu")
+
+[node name="VBoxContainer" type="VBoxContainer" parent="."]
+layout_mode = 1
+anchors_preset = 15
+anchor_right = 1.0
+anchor_bottom = 1.0
+grow_horizontal = 2
+grow_vertical = 2
+
+[node name="TitleLabel" type="Label" parent="VBoxContainer"]
+layout_mode = 2
+text = "Godot MCP Server"
+horizontal_alignment = 1
+
+[node name="HSeparator" type="HSeparator" parent="VBoxContainer"]
+layout_mode = 2
+
+[node name="StatusContainer" type="HBoxContainer" parent="VBoxContainer"]
+layout_mode = 2
+
+[node name="Label" type="Label" parent="VBoxContainer/StatusContainer"]
+layout_mode = 2
+text = "Status:"
+
+[node name="StatusLabel" type="Label" parent="VBoxContainer/StatusContainer"]
+layout_mode = 2
+size_flags_horizontal = 3
+text = "Server: Stopped"
+
+[node name="PortContainer" type="HBoxContainer" parent="VBoxContainer"]
+layout_mode = 2
+
+[node name="Label" type="Label" parent="VBoxContainer/PortContainer"]
+layout_mode = 2
+text = "Port:"
+
+[node name="PortSpinBox" type="SpinBox" parent="VBoxContainer/PortContainer"]
+layout_mode = 2
+size_flags_horizontal = 3
+min_value = 1.0
+max_value = 65535.0
+value = 9080.0
+
+[node name="ButtonsContainer" type="HBoxContainer" parent="VBoxContainer"]
+layout_mode = 2
+
+[node name="StartButton" type="Button" parent="VBoxContainer/ButtonsContainer"]
+layout_mode = 2
+size_flags_horizontal = 3
+text = "Start Server"
+
+[node name="StopButton" type="Button" parent="VBoxContainer/ButtonsContainer"]
+layout_mode = 2
+size_flags_horizontal = 3
+disabled = true
+text = "Stop Server"
+
+[node name="ConnectionsContainer" type="HBoxContainer" parent="VBoxContainer"]
+layout_mode = 2
+
+[node name="Label" type="Label" parent="VBoxContainer/ConnectionsContainer"]
+layout_mode = 2
+text = "Connected Clients:"
+
+[node name="CountLabel" type="Label" parent="VBoxContainer/ConnectionsContainer"]
+layout_mode = 2
+text = "0"
+
+[node name="HSeparator2" type="HSeparator" parent="VBoxContainer"]
+layout_mode = 2
+
+[node name="LogLabel" type="Label" parent="VBoxContainer"]
+layout_mode = 2
+text = "Server Log:"
+
+[node name="LogContainer" type="VBoxContainer" parent="VBoxContainer"]
+layout_mode = 2
+size_flags_vertical = 3
+
+[node name="LogText" type="TextEdit" parent="VBoxContainer/LogContainer"]
+layout_mode = 2
+size_flags_vertical = 3
+editable = false
+wrap_mode = 1

package/addons/godot_mcp/utils/node_utils.gd

@@ -0,0 +1,82 @@
+@tool
+class_name NodeUtils
+extends RefCounted
+
+# Get all nodes of a certain type in the scene tree
+static func get_nodes_by_type(root_node: Node, type_name: String) -> Array[Node]:
+	var result: Array[Node] = []
+	
+	if root_node.get_class() == type_name:
+		result.push_back(root_node)
+	
+	for child in root_node.get_children():
+		result.append_array(get_nodes_by_type(child, type_name))
+	
+	return result
+
+# Get a node by its path, or null if not found
+static func find_node_by_path(root_node: Node, path: String) -> Node:
+	if path.is_empty():
+		return null
+	
+	if path.begins_with("/"):
+		path = path.substr(1)
+	
+	var path_parts = path.split("/")
+	var current_node = root_node
+	
+	for part in path_parts:
+		var found = false
+		for child in current_node.get_children():
+			if child.name == part:
+				current_node = child
+				found = true
+				break
+		
+		if not found:
+			return null
+	
+	return current_node
+
+# Convert a node to a JSON-compatible dictionary
+static func node_to_dict(node: Node) -> Dictionary:
+	var result = {
+		"name": node.name,
+		"type": node.get_class(),
+		"path": str(node.get_path()),
+		"properties": {}
+	}
+	
+	# Get properties
+	var properties = {}
+	var property_list = node.get_property_list()
+	
+	for prop in property_list:
+		var name = prop["name"]
+		if not name.begins_with("_"): # Skip internal properties
+			result["properties"][name] = node.get(name)
+	
+	# Get children
+	var children = []
+	for child in node.get_children():
+		children.append({
+			"name": child.name,
+			"type": child.get_class(),
+			"path": str(child.get_path())
+		})
+	
+	result["children"] = children
+	
+	return result
+
+# Create a screenshot of a node (only works for CanvasItem nodes)
+static func take_node_screenshot(node: CanvasItem) -> Image:
+	if not node is CanvasItem:
+		push_error("Can only take screenshots of CanvasItem nodes")
+		return null
+	
+	var viewport = node.get_viewport()
+	if not viewport:
+		return null
+	
+	return viewport.get_texture().get_image()

package/addons/godot_mcp/utils/node_utils.gd.uid

@@ -0,0 +1 @@
+uid://bo1e0xfs0v0d