@satelliteoflove/godot-mcp 2.2.0 → 2.4.0

package/addon/commands/debug_commands.gd

@@ -0,0 +1,109 @@
+@tool
+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
+	}
+
+
+func run_project(params: Dictionary) -> Dictionary:
+	var scene_path: String = params.get("scene_path", "")
+
+	MCPLogger.clear()
+
+	if scene_path.is_empty():
+		EditorInterface.play_main_scene()
+	else:
+		EditorInterface.play_custom_scene(scene_path)
+
+	return _success({})
+
+
+func stop_project(_params: Dictionary) -> Dictionary:
+	EditorInterface.stop_playing_scene()
+	return _success({})
+
+
+func get_debug_output(params: Dictionary) -> Dictionary:
+	var clear: bool = params.get("clear", false)
+
+	if not EditorInterface.is_playing_scene():
+		var output := "\n".join(MCPLogger.get_output())
+		if clear:
+			MCPLogger.clear()
+		return _success({"output": output})
+
+	var debugger_plugin = _plugin.get_debugger_plugin() if _plugin else null
+	if debugger_plugin == null or not debugger_plugin.has_active_session():
+		var output := "\n".join(MCPLogger.get_output())
+		if clear:
+			MCPLogger.clear()
+		return _success({"output": output})
+
+	_debug_output_pending = true
+	_debug_output_result = PackedStringArray()
+
+	debugger_plugin.debug_output_received.connect(_on_debug_output_received, CONNECT_ONE_SHOT)
+	debugger_plugin.request_debug_output(clear)
+
+	var start_time := Time.get_ticks_msec()
+	while _debug_output_pending:
+		await Engine.get_main_loop().process_frame
+		if (Time.get_ticks_msec() - start_time) / 1000.0 > DEBUG_OUTPUT_TIMEOUT:
+			_debug_output_pending = false
+			if debugger_plugin.debug_output_received.is_connected(_on_debug_output_received):
+				debugger_plugin.debug_output_received.disconnect(_on_debug_output_received)
+			return _success({"output": "\n".join(MCPLogger.get_output())})
+
+	return _success({"output": "\n".join(_debug_output_result)})
+
+
+func _on_debug_output_received(output: PackedStringArray) -> void:
+	_debug_output_pending = false
+	_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

package/addon/commands/debug_commands.gd.uid

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

package/addon/commands/file_commands.gd

@@ -0,0 +1,95 @@
+@tool
+extends MCPBaseCommand
+class_name MCPFileCommands
+
+
+func get_commands() -> Dictionary:
+	return {
+		"list_project_files": list_project_files,
+		"search_files": search_files
+	}
+
+
+func list_project_files(params: Dictionary) -> Dictionary:
+	var file_type: String = params.get("file_type", "all")
+	var directory: String = params.get("directory", "res://")
+	var recursive: bool = params.get("recursive", true)
+
+	var extensions: PackedStringArray
+	match file_type:
+		"scripts":
+			extensions = PackedStringArray(["gd", "cs"])
+		"scenes":
+			extensions = PackedStringArray(["tscn", "scn"])
+		"resources":
+			extensions = PackedStringArray(["tres", "res"])
+		"images":
+			extensions = PackedStringArray(["png", "jpg", "jpeg", "webp", "svg"])
+		"audio":
+			extensions = PackedStringArray(["ogg", "mp3", "wav"])
+		"all":
+			extensions = PackedStringArray()
+		_:
+			return _error("INVALID_TYPE", "Unknown file type: %s" % file_type)
+
+	var files := _scan_directory(directory, extensions, recursive)
+	return _success({"files": files})
+
+
+func search_files(params: Dictionary) -> Dictionary:
+	var pattern: String = params.get("pattern", "")
+	var directory: String = params.get("directory", "res://")
+
+	if pattern.is_empty():
+		return _error("INVALID_PARAMS", "pattern is required")
+
+	var all_files := _scan_directory(directory, PackedStringArray(), true)
+	var matching: Array[String] = []
+
+	for file_path in all_files:
+		var file_name := file_path.get_file()
+		if _matches_pattern(file_name, pattern):
+			matching.append(file_path)
+
+	return _success({"files": matching})
+
+
+func _scan_directory(path: String, extensions: PackedStringArray, recursive: bool) -> Array[String]:
+	var files: Array[String] = []
+	var dir := DirAccess.open(path)
+
+	if not dir:
+		return files
+
+	dir.list_dir_begin()
+	var file_name := dir.get_next()
+
+	while not file_name.is_empty():
+		var full_path := path.path_join(file_name)
+
+		if dir.current_is_dir():
+			if recursive and not file_name.begins_with("."):
+				files.append_array(_scan_directory(full_path, extensions, recursive))
+		else:
+			if extensions.is_empty():
+				files.append(full_path)
+			else:
+				var ext := file_name.get_extension().to_lower()
+				if ext in extensions:
+					files.append(full_path)
+
+		file_name = dir.get_next()
+
+	dir.list_dir_end()
+	return files
+
+
+func _matches_pattern(text: String, pattern: String) -> bool:
+	if not "*" in pattern:
+		return pattern.to_lower() in text.to_lower()
+
+	var regex_pattern := "^" + pattern.replace(".", "\\.").replace("*", ".*") + "$"
+	var regex := RegEx.new()
+	regex.compile(regex_pattern)
+
+	return regex.search(text.to_lower()) != null

package/addon/commands/file_commands.gd.uid

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

package/addon/commands/node_commands.gd

@@ -0,0 +1,252 @@
+@tool
+extends MCPBaseCommand
+class_name MCPNodeCommands
+
+var _find_nodes_pending := false
+var _find_nodes_result: Dictionary = {}
+
+
+func get_commands() -> Dictionary:
+	return {
+		"get_node_properties": get_node_properties,
+		"find_nodes": find_nodes,
+		"create_node": create_node,
+		"update_node": update_node,
+		"delete_node": delete_node,
+		"reparent_node": reparent_node
+	}
+
+
+func _require_scene_open() -> Dictionary:
+	var root := EditorInterface.get_edited_scene_root()
+	if not root:
+		return _error("NO_SCENE", "No scene is currently open")
+	return {}
+
+
+func get_node_properties(params: Dictionary) -> Dictionary:
+	var node_path: String = params.get("node_path", "")
+	if node_path.is_empty():
+		return _error("INVALID_PARAMS", "node_path is required")
+
+	var node := _get_node(node_path)
+	if not node:
+		return _error("NODE_NOT_FOUND", "Node not found: %s" % node_path)
+
+	var properties := {}
+	for prop in node.get_property_list():
+		var name: String = prop["name"]
+		if name.begins_with("_") or prop["usage"] & PROPERTY_USAGE_SCRIPT_VARIABLE == 0:
+			if prop["usage"] & PROPERTY_USAGE_EDITOR == 0:
+				continue
+
+		var value = node.get(name)
+		properties[name] = _serialize_value(value)
+
+	return _success({"properties": properties})
+
+
+func find_nodes(params: Dictionary) -> Dictionary:
+	var name_pattern: String = params.get("name_pattern", "")
+	var type_filter: String = params.get("type", "")
+	var root_path: String = params.get("root_path", "")
+
+	if name_pattern.is_empty() and type_filter.is_empty():
+		return _error("INVALID_PARAMS", "At least one of name_pattern or type is required")
+
+	var debugger := _plugin.get_debugger_plugin() as MCPDebuggerPlugin
+	if debugger and debugger.has_active_session():
+		return await _find_nodes_via_game(debugger, name_pattern, type_filter, root_path)
+
+	var scene_check := _require_scene_open()
+	if not scene_check.is_empty():
+		return scene_check
+
+	var scene_root := EditorInterface.get_edited_scene_root()
+	var search_root: Node = scene_root
+
+	if not root_path.is_empty():
+		search_root = _get_node(root_path)
+		if not search_root:
+			return _error("NODE_NOT_FOUND", "Root node not found: %s" % root_path)
+
+	var matches: Array[Dictionary] = []
+	_find_recursive(search_root, scene_root, name_pattern, type_filter, matches)
+
+	return _success({"matches": matches, "count": matches.size()})
+
+
+func _find_nodes_via_game(debugger: MCPDebuggerPlugin, name_pattern: String, type_filter: String, root_path: String) -> Dictionary:
+	_find_nodes_pending = true
+	_find_nodes_result = {}
+
+	debugger.find_nodes_received.connect(_on_find_nodes_received, CONNECT_ONE_SHOT)
+	debugger.request_find_nodes(name_pattern, type_filter, root_path)
+
+	while _find_nodes_pending:
+		await Engine.get_main_loop().process_frame
+
+	return _find_nodes_result
+
+
+func _on_find_nodes_received(matches: Array, count: int, error: String) -> void:
+	_find_nodes_pending = false
+	if not error.is_empty():
+		_find_nodes_result = _error("GAME_ERROR", error)
+	else:
+		_find_nodes_result = _success({"matches": matches, "count": count})
+
+
+func _find_recursive(node: Node, scene_root: Node, name_pattern: String, type_filter: String, results: Array[Dictionary]) -> void:
+	var name_matches := name_pattern.is_empty() or node.name.matchn(name_pattern)
+	var type_matches := type_filter.is_empty() or node.is_class(type_filter)
+
+	if name_matches and type_matches:
+		var relative_path := scene_root.get_path_to(node)
+		var usable_path := "/root/" + scene_root.name
+		if relative_path != NodePath("."):
+			usable_path += "/" + str(relative_path)
+
+		results.append({
+			"path": usable_path,
+			"type": node.get_class()
+		})
+
+	for child in node.get_children():
+		_find_recursive(child, scene_root, name_pattern, type_filter, results)
+
+
+func create_node(params: Dictionary) -> Dictionary:
+	var scene_check := _require_scene_open()
+	if not scene_check.is_empty():
+		return scene_check
+
+	var parent_path: String = params.get("parent_path", "")
+	var node_type: String = params.get("node_type", "")
+	var scene_path: String = params.get("scene_path", "")
+	var node_name: String = params.get("node_name", "")
+	var properties: Dictionary = params.get("properties", {})
+
+	if parent_path.is_empty():
+		return _error("INVALID_PARAMS", "parent_path is required")
+	if node_name.is_empty():
+		return _error("INVALID_PARAMS", "node_name is required")
+	if node_type.is_empty() and scene_path.is_empty():
+		return _error("INVALID_PARAMS", "Either node_type or scene_path is required")
+	if not node_type.is_empty() and not scene_path.is_empty():
+		return _error("INVALID_PARAMS", "Provide node_type OR scene_path, not both")
+
+	var parent := _get_node(parent_path)
+	if not parent:
+		return _error("NODE_NOT_FOUND", "Parent node not found: %s" % parent_path)
+
+	var node: Node
+	if not scene_path.is_empty():
+		if not ResourceLoader.exists(scene_path):
+			return _error("SCENE_NOT_FOUND", "Scene not found: %s" % scene_path)
+		var packed_scene: PackedScene = load(scene_path)
+		if not packed_scene:
+			return _error("LOAD_FAILED", "Failed to load scene: %s" % scene_path)
+		node = packed_scene.instantiate(PackedScene.GEN_EDIT_STATE_INSTANCE)
+		if not node:
+			return _error("INSTANTIATE_FAILED", "Failed to instantiate: %s" % scene_path)
+	else:
+		if not ClassDB.class_exists(node_type):
+			return _error("INVALID_TYPE", "Unknown node type: %s" % node_type)
+		node = ClassDB.instantiate(node_type)
+		if not node:
+			return _error("CREATE_FAILED", "Failed to create node of type: %s" % node_type)
+
+	node.name = node_name
+
+	for key in properties:
+		if node.has_method("set") and key in node:
+			var deserialized := MCPUtils.deserialize_value(properties[key])
+			node.set(key, deserialized)
+
+	parent.add_child(node)
+	_set_owner_recursive(node, EditorInterface.get_edited_scene_root())
+
+	return _success({"node_path": str(node.get_path())})
+
+
+func _set_owner_recursive(node: Node, owner: Node) -> void:
+	node.owner = owner
+	for child in node.get_children():
+		_set_owner_recursive(child, owner)
+
+
+func update_node(params: Dictionary) -> Dictionary:
+	var node_path: String = params.get("node_path", "")
+	var properties: Dictionary = params.get("properties", {})
+
+	if node_path.is_empty():
+		return _error("INVALID_PARAMS", "node_path is required")
+	if properties.is_empty():
+		return _error("INVALID_PARAMS", "properties is required")
+
+	var node := _get_node(node_path)
+	if not node:
+		return _error("NODE_NOT_FOUND", "Node not found: %s" % node_path)
+
+	for key in properties:
+		if key in node:
+			var deserialized := MCPUtils.deserialize_value(properties[key])
+			node.set(key, deserialized)
+
+	return _success({})
+
+
+func delete_node(params: Dictionary) -> Dictionary:
+	var scene_check := _require_scene_open()
+	if not scene_check.is_empty():
+		return scene_check
+
+	var node_path: String = params.get("node_path", "")
+	if node_path.is_empty():
+		return _error("INVALID_PARAMS", "node_path is required")
+
+	var node := _get_node(node_path)
+	if not node:
+		return _error("NODE_NOT_FOUND", "Node not found: %s" % node_path)
+
+	var root := EditorInterface.get_edited_scene_root()
+	if node == root:
+		return _error("CANNOT_DELETE_ROOT", "Cannot delete the root node")
+
+	node.get_parent().remove_child(node)
+	node.queue_free()
+
+	return _success({})
+
+
+func reparent_node(params: Dictionary) -> Dictionary:
+	var scene_check := _require_scene_open()
+	if not scene_check.is_empty():
+		return scene_check
+
+	var node_path: String = params.get("node_path", "")
+	var new_parent_path: String = params.get("new_parent_path", "")
+
+	if node_path.is_empty():
+		return _error("INVALID_PARAMS", "node_path is required")
+	if new_parent_path.is_empty():
+		return _error("INVALID_PARAMS", "new_parent_path is required")
+
+	var node := _get_node(node_path)
+	if not node:
+		return _error("NODE_NOT_FOUND", "Node not found: %s" % node_path)
+
+	var new_parent := _get_node(new_parent_path)
+	if not new_parent:
+		return _error("NODE_NOT_FOUND", "New parent not found: %s" % new_parent_path)
+
+	var root := EditorInterface.get_edited_scene_root()
+	if node == root:
+		return _error("CANNOT_REPARENT_ROOT", "Cannot reparent the root node")
+
+	node.reparent(new_parent)
+
+	return _success({"new_path": str(node.get_path())})
+
+

package/addon/commands/node_commands.gd.uid

@@ -0,0 +1 @@
+uid://68p58x7fq2ve

package/addon/commands/project_commands.gd

@@ -0,0 +1,114 @@
+@tool
+extends MCPBaseCommand
+class_name MCPProjectCommands
+
+
+func get_commands() -> Dictionary:
+	return {
+		"get_project_info": get_project_info,
+		"get_project_settings": get_project_settings
+	}
+
+
+func get_project_info(_params: Dictionary) -> Dictionary:
+	return _success({
+		"name": ProjectSettings.get_setting("application/config/name", "Unknown"),
+		"path": ProjectSettings.globalize_path("res://"),
+		"godot_version": Engine.get_version_info()["string"],
+		"main_scene": ProjectSettings.get_setting("application/run/main_scene", null)
+	})
+
+
+func get_project_settings(params: Dictionary) -> Dictionary:
+	var category: String = params.get("category", "")
+
+	if category == "input":
+		return _get_input_mappings(params)
+
+	var settings := {}
+	var all_settings := ProjectSettings.get_property_list()
+
+	for prop in all_settings:
+		var name: String = prop["name"]
+		if not category.is_empty() and not name.begins_with(category):
+			continue
+		if prop["usage"] & PROPERTY_USAGE_EDITOR:
+			settings[name] = _serialize_value(ProjectSettings.get_setting(name))
+
+	return _success({"settings": settings})
+
+
+func _get_input_mappings(params: Dictionary) -> Dictionary:
+	var include_builtin: bool = params.get("include_builtin", false)
+	var actions := {}
+
+	# Read from ProjectSettings instead of InputMap
+	# InputMap in editor context only has editor actions, not game inputs
+	# Game inputs are stored as "input/<action_name>" in ProjectSettings
+	var all_settings := ProjectSettings.get_property_list()
+
+	for prop in all_settings:
+		var name: String = prop["name"]
+		if not name.begins_with("input/"):
+			continue
+
+		var action_name := name.substr(6)  # Remove "input/" prefix
+
+		if not include_builtin and action_name.begins_with("ui_"):
+			continue
+
+		var action_data = ProjectSettings.get_setting(name)
+		if action_data is Dictionary:
+			var events := []
+			var raw_events = action_data.get("events", [])
+			for event in raw_events:
+				if event is InputEvent:
+					events.append(_serialize_input_event(event))
+
+			actions[action_name] = {
+				"deadzone": action_data.get("deadzone", 0.5),
+				"events": events
+			}
+
+	return _success({"settings": actions})
+
+
+func _serialize_input_event(event: InputEvent) -> Dictionary:
+	if event is InputEventKey:
+		var keycode: int = event.keycode if event.keycode else event.physical_keycode
+		return {
+			"type": "key",
+			"keycode": event.keycode,
+			"physical_keycode": event.physical_keycode,
+			"key_label": OS.get_keycode_string(keycode),
+			"modifiers": _get_modifiers(event)
+		}
+	elif event is InputEventMouseButton:
+		return {
+			"type": "mouse_button",
+			"button_index": event.button_index,
+			"modifiers": _get_modifiers(event)
+		}
+	elif event is InputEventJoypadButton:
+		return {
+			"type": "joypad_button",
+			"button_index": event.button_index,
+			"device": event.device
+		}
+	elif event is InputEventJoypadMotion:
+		return {
+			"type": "joypad_motion",
+			"axis": event.axis,
+			"axis_value": event.axis_value,
+			"device": event.device
+		}
+	return {"type": "unknown", "event": str(event)}
+
+
+func _get_modifiers(event: InputEventWithModifiers) -> Dictionary:
+	return {
+		"shift": event.shift_pressed,
+		"ctrl": event.ctrl_pressed,
+		"alt": event.alt_pressed,
+		"meta": event.meta_pressed
+	}

package/addon/commands/project_commands.gd.uid

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