@baixfeng/godot-mcp-cli 1.0.11

package/addons/godot_mcp/commands/node_commands.gd

@@ -0,0 +1,222 @@
+@tool
+class_name MCPNodeCommands
+extends MCPBaseCommandProcessor
+
+func process_command(client_id: int, command_type: String, params: Dictionary, command_id: String) -> bool:
+	match command_type:
+		"create_node":
+			_create_node(client_id, params, command_id)
+			return true
+		"delete_node":
+			_delete_node(client_id, params, command_id)
+			return true
+		"update_node_property":
+			_update_node_property(client_id, params, command_id)
+			return true
+		"get_node_properties":
+			_get_node_properties(client_id, params, command_id)
+			return true
+		"list_nodes":
+			_list_nodes(client_id, params, command_id)
+			return true
+	return false  # Command not handled
+
+func _create_node(client_id: int, params: Dictionary, command_id: String) -> void:
+	var parent_path = params.get("parent_path", ".")
+	var node_type = params.get("node_type", "Node")
+	var node_name = params.get("node_name", "NewNode")
+
+	# Validation
+	if not ClassDB.class_exists(node_type):
+		return _send_error(client_id, "Invalid node type: %s" % node_type, command_id)
+
+	# Get editor plugin and interfaces
+	var plugin = Engine.get_meta("GodotMCPPlugin")
+	if not plugin:
+		return _send_error(client_id, "GodotMCPPlugin not found in Engine metadata", command_id)
+
+	var editor_interface = plugin.get_editor_interface()
+	var edited_scene_root = editor_interface.get_edited_scene_root()
+
+	if not edited_scene_root:
+		return _send_error(client_id, "No scene is currently being edited", command_id)
+
+	# Get the parent node using the editor node helper
+	var parent = _get_editor_node(parent_path)
+	if not parent:
+		return _send_error(client_id, "Parent node not found: %s" % parent_path, command_id)
+
+	# Create the node
+	var node
+	if ClassDB.can_instantiate(node_type):
+		node = ClassDB.instantiate(node_type)
+	else:
+		return _send_error(client_id, "Cannot instantiate node of type: %s" % node_type, command_id)
+
+	if not node:
+		return _send_error(client_id, "Failed to create node of type: %s" % node_type, command_id)
+
+	# Set the node name
+	node.name = node_name
+
+	# Add the node to the parent
+	parent.add_child(node)
+
+	# Set owner for proper serialization
+	node.owner = edited_scene_root
+
+	# Mark the scene as modified
+	_mark_scene_modified()
+
+	_send_success(client_id, {
+		"node_path": parent_path + "/" + node_name
+	}, command_id)
+
+func _delete_node(client_id: int, params: Dictionary, command_id: String) -> void:
+	var node_path = params.get("node_path", "")
+
+	# Validation
+	if node_path.is_empty():
+		return _send_error(client_id, "Node path cannot be empty", command_id)
+
+	# Get editor plugin and interfaces
+	var plugin = Engine.get_meta("GodotMCPPlugin")
+	if not plugin:
+		return _send_error(client_id, "GodotMCPPlugin not found in Engine metadata", command_id)
+
+	var editor_interface = plugin.get_editor_interface()
+	var edited_scene_root = editor_interface.get_edited_scene_root()
+
+	if not edited_scene_root:
+		return _send_error(client_id, "No scene is currently being edited", command_id)
+
+	# Get the node using the editor node helper
+	var node = _get_editor_node(node_path)
+	if not node:
+		return _send_error(client_id, "Node not found: %s" % node_path, command_id)
+
+	# Cannot delete the root node
+	if node == edited_scene_root:
+		return _send_error(client_id, "Cannot delete the root node", command_id)
+
+	# Get parent for operation
+	var parent = node.get_parent()
+	if not parent:
+		return _send_error(client_id, "Node has no parent: %s" % node_path, command_id)
+
+	# Remove the node
+	parent.remove_child(node)
+	node.queue_free()
+
+	# Mark the scene as modified
+	_mark_scene_modified()
+
+	_send_success(client_id, {
+		"deleted_node_path": node_path
+	}, command_id)
+
+func _update_node_property(client_id: int, params: Dictionary, command_id: String) -> void:
+	var node_path = params.get("node_path", "")
+	var property_name = params.get("property", "")
+	var property_value = params.get("value")
+
+	# Validation
+	if node_path.is_empty():
+		return _send_error(client_id, "Node path cannot be empty", command_id)
+
+	if property_name.is_empty():
+		return _send_error(client_id, "Property name cannot be empty", command_id)
+
+	if property_value == null:
+		return _send_error(client_id, "Property value cannot be null", command_id)
+
+	# Get editor plugin and interfaces
+	var plugin = Engine.get_meta("GodotMCPPlugin")
+	if not plugin:
+		return _send_error(client_id, "GodotMCPPlugin not found in Engine metadata", command_id)
+
+	# Get the node using the editor node helper
+	var node = _get_editor_node(node_path)
+	if not node:
+		return _send_error(client_id, "Node not found: %s" % node_path, command_id)
+
+	# Check if the property exists
+	if not property_name in node:
+		return _send_error(client_id, "Property %s does not exist on node %s" % [property_name, node_path], command_id)
+
+	# Parse property value for Godot types
+	var parsed_value = _parse_property_value(property_value)
+
+	# Get current property value for undo
+	var old_value = node.get(property_name)
+
+	# Get undo/redo system
+	var undo_redo = _get_undo_redo()
+	if not undo_redo:
+		# Fallback method if we can't get undo/redo
+		node.set(property_name, parsed_value)
+		_mark_scene_modified()
+	else:
+		# Use undo/redo for proper editor integration
+		undo_redo.create_action("Update Property: " + property_name)
+		undo_redo.add_do_property(node, property_name, parsed_value)
+		undo_redo.add_undo_property(node, property_name, old_value)
+		undo_redo.commit_action()
+
+	# Mark the scene as modified
+	_mark_scene_modified()
+
+	_send_success(client_id, {
+		"node_path": node_path,
+		"property": property_name,
+		"value": property_value,
+		"parsed_value": str(parsed_value)
+	}, command_id)
+
+func _get_node_properties(client_id: int, params: Dictionary, command_id: String) -> void:
+	var node_path = params.get("node_path", "")
+
+	# Validation
+	if node_path.is_empty():
+		return _send_error(client_id, "Node path cannot be empty", command_id)
+
+	# Get the node using the editor node helper
+	var node = _get_editor_node(node_path)
+	if not node:
+		return _send_error(client_id, "Node not found: %s" % node_path, command_id)
+
+	# Get all 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
+			properties[name] = node.get(name)
+
+	_send_success(client_id, {
+		"node_path": node_path,
+		"properties": properties
+	}, command_id)
+
+func _list_nodes(client_id: int, params: Dictionary, command_id: String) -> void:
+	var parent_path = params.get("parent_path", ".")
+
+	# Get the parent node using the editor node helper
+	var parent = _get_editor_node(parent_path)
+	if not parent:
+		return _send_error(client_id, "Parent node not found: %s" % parent_path, command_id)
+
+	# Get children
+	var children = []
+	for child in parent.get_children():
+		children.append({
+			"name": child.name,
+			"type": child.get_class(),
+			"path": str(child.get_path()).replace(str(parent.get_path()), parent_path)
+		})
+
+	_send_success(client_id, {
+		"parent_path": parent_path,
+		"children": children
+	}, command_id)

package/addons/godot_mcp/commands/node_commands.gd.uid

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

package/addons/godot_mcp/commands/project_commands.gd

@@ -0,0 +1,298 @@
+@tool
+class_name MCPProjectCommands
+extends MCPBaseCommandProcessor
+
+func process_command(client_id: int, command_type: String, params: Dictionary, command_id: String) -> bool:
+	match command_type:
+		"get_project_info":
+			_get_project_info(client_id, params, command_id)
+			return true
+		"list_project_files":
+			_list_project_files(client_id, params, command_id)
+			return true
+		"get_project_structure":
+			_get_project_structure(client_id, params, command_id)
+			return true
+		"get_project_settings":
+			_get_project_settings(client_id, params, command_id)
+			return true
+		"list_project_resources":
+			_list_project_resources(client_id, params, command_id)
+			return true
+		"run_project":
+			_run_project(client_id, params, command_id)
+			return true
+		"stop_running_project":
+			_stop_running_project(client_id, params, command_id)
+			return true
+		"run_current_scene":
+			_run_current_scene(client_id, params, command_id)
+			return true
+		"run_specific_scene":
+			_run_specific_scene(client_id, params, command_id)
+			return true
+	return false  # Command not handled
+
+func _get_project_info(client_id: int, _params: Dictionary, command_id: String) -> void:
+	var project_name = ProjectSettings.get_setting("application/config/name", "Untitled Project")
+	var project_version = ProjectSettings.get_setting("application/config/version", "1.0.0")
+	var project_path = ProjectSettings.globalize_path("res://")
+	
+	# Get Godot version info and structure it as expected by the server
+	var version_info = Engine.get_version_info()
+	print("Raw Godot version info: ", version_info)
+	
+	# Create structured version object with the expected properties
+	var structured_version = {
+		"major": version_info.get("major", 0),
+		"minor": version_info.get("minor", 0),
+		"patch": version_info.get("patch", 0)
+	}
+	
+	_send_success(client_id, {
+		"project_name": project_name,
+		"project_version": project_version,
+		"project_path": project_path,
+		"godot_version": structured_version,
+		"current_scene": get_tree().edited_scene_root.scene_file_path if get_tree().edited_scene_root else ""
+	}, command_id)
+
+func _list_project_files(client_id: int, params: Dictionary, command_id: String) -> void:
+	var extensions = params.get("extensions", [])
+	var files = []
+	
+	# Get all files with the specified extensions
+	var dir = DirAccess.open("res://")
+	if dir:
+		_scan_directory(dir, "", extensions, files)
+	else:
+		return _send_error(client_id, "Failed to open res:// directory", command_id)
+	
+	_send_success(client_id, {
+		"files": files
+	}, command_id)
+
+func _scan_directory(dir: DirAccess, path: String, extensions: Array, files: Array) -> void:
+	dir.list_dir_begin()
+	var file_name = dir.get_next()
+	
+	while file_name != "":
+		if dir.current_is_dir():
+			var subdir = DirAccess.open("res://" + path + file_name)
+			if subdir:
+				_scan_directory(subdir, path + file_name + "/", extensions, files)
+		else:
+			var file_path = path + file_name
+			var has_valid_extension = extensions.is_empty()
+			
+			for ext in extensions:
+				if file_name.ends_with(ext):
+					has_valid_extension = true
+					break
+			
+			if has_valid_extension:
+				files.append("res://" + file_path)
+		
+		file_name = dir.get_next()
+	
+	dir.list_dir_end()
+
+func _get_project_structure(client_id: int, params: Dictionary, command_id: String) -> void:
+	var structure = {
+		"directories": [],
+		"file_counts": {},
+		"total_files": 0
+	}
+	
+	var dir = DirAccess.open("res://")
+	if dir:
+		_analyze_project_structure(dir, "", structure)
+	else:
+		return _send_error(client_id, "Failed to open res:// directory", command_id)
+	
+	_send_success(client_id, structure, command_id)
+
+func _analyze_project_structure(dir: DirAccess, path: String, structure: Dictionary) -> void:
+	dir.list_dir_begin()
+	var file_name = dir.get_next()
+	
+	while file_name != "":
+		if dir.current_is_dir():
+			var dir_path = path + file_name + "/"
+			structure["directories"].append("res://" + dir_path)
+			
+			var subdir = DirAccess.open("res://" + dir_path)
+			if subdir:
+				_analyze_project_structure(subdir, dir_path, structure)
+		else:
+			structure["total_files"] += 1
+			
+			var extension = file_name.get_extension()
+			if extension in structure["file_counts"]:
+				structure["file_counts"][extension] += 1
+			else:
+				structure["file_counts"][extension] = 1
+		
+		file_name = dir.get_next()
+	
+	dir.list_dir_end()
+
+func _get_project_settings(client_id: int, params: Dictionary, command_id: String) -> void:
+	# Get relevant project settings
+	var settings = {
+		"project_name": ProjectSettings.get_setting("application/config/name", "Untitled Project"),
+		"project_version": ProjectSettings.get_setting("application/config/version", "1.0.0"),
+		"display": {
+			"width": ProjectSettings.get_setting("display/window/size/viewport_width", 1024),
+			"height": ProjectSettings.get_setting("display/window/size/viewport_height", 600),
+			"mode": ProjectSettings.get_setting("display/window/size/mode", 0),
+			"resizable": ProjectSettings.get_setting("display/window/size/resizable", true)
+		},
+		"physics": {
+			"2d": {
+				"default_gravity": ProjectSettings.get_setting("physics/2d/default_gravity", 980)
+			},
+			"3d": {
+				"default_gravity": ProjectSettings.get_setting("physics/3d/default_gravity", 9.8)
+			}
+		},
+		"rendering": {
+			"quality": {
+				"msaa": ProjectSettings.get_setting("rendering/anti_aliasing/quality/msaa_2d", 0)
+			}
+		},
+		"input_map": {}
+	}
+	
+	# Get input mappings
+	var input_map = ProjectSettings.get_setting("input")
+	if input_map:
+		settings["input_map"] = input_map
+	
+	_send_success(client_id, settings, command_id)
+
+func _list_project_resources(client_id: int, params: Dictionary, command_id: String) -> void:
+	var resources = {
+		"scenes": [],
+		"scripts": [],
+		"textures": [],
+		"audio": [],
+		"models": [],
+		"resources": []
+	}
+	
+	var dir = DirAccess.open("res://")
+	if dir:
+		_scan_resources(dir, "", resources)
+	else:
+		return _send_error(client_id, "Failed to open res:// directory", command_id)
+	
+	_send_success(client_id, resources, command_id)
+
+func _scan_resources(dir: DirAccess, path: String, resources: Dictionary) -> void:
+	dir.list_dir_begin()
+	var file_name = dir.get_next()
+	
+	while file_name != "":
+		if dir.current_is_dir():
+			var subdir = DirAccess.open("res://" + path + file_name)
+			if subdir:
+				_scan_resources(subdir, path + file_name + "/", resources)
+		else:
+			var file_path = "res://" + path + file_name
+			
+			# Categorize by extension
+			if file_name.ends_with(".tscn") or file_name.ends_with(".scn"):
+				resources["scenes"].append(file_path)
+			elif file_name.ends_with(".gd") or file_name.ends_with(".cs"):
+				resources["scripts"].append(file_path)
+			elif file_name.ends_with(".png") or file_name.ends_with(".jpg") or file_name.ends_with(".jpeg"):
+				resources["textures"].append(file_path)
+			elif file_name.ends_with(".wav") or file_name.ends_with(".ogg") or file_name.ends_with(".mp3"):
+				resources["audio"].append(file_path)
+			elif file_name.ends_with(".obj") or file_name.ends_with(".glb") or file_name.ends_with(".gltf"):
+				resources["models"].append(file_path)
+			elif file_name.ends_with(".tres") or file_name.ends_with(".res"):
+				resources["resources"].append(file_path)
+		
+		file_name = dir.get_next()
+	
+	dir.list_dir_end()
+
+func _run_project(client_id: int, _params: Dictionary, command_id: String) -> void:
+	var editor_interface = _get_editor_interface()
+	if not editor_interface:
+		return _send_error(client_id, "Editor interface not available", command_id)
+	
+	var main_scene: String = ProjectSettings.get_setting("application/run/main_scene", "")
+	if main_scene.is_empty():
+		return _send_error(client_id, "No main scene configured in project settings", command_id)
+	
+	editor_interface.play_main_scene()
+	_send_success(client_id, {
+		"status": "running",
+		"scene_path": main_scene
+	}, command_id)
+
+func _stop_running_project(client_id: int, _params: Dictionary, command_id: String) -> void:
+	var editor_interface = _get_editor_interface()
+	if not editor_interface:
+		return _send_error(client_id, "Editor interface not available", command_id)
+	
+	if not editor_interface.is_playing_scene():
+		return _send_success(client_id, {
+			"status": "idle",
+			"message": "Editor is not currently running a scene"
+		}, command_id)
+	
+	editor_interface.stop_playing_scene()
+	_send_success(client_id, {
+		"status": "stopped"
+	}, command_id)
+
+func _run_current_scene(client_id: int, _params: Dictionary, command_id: String) -> void:
+	var editor_interface = _get_editor_interface()
+	if not editor_interface:
+		return _send_error(client_id, "Editor interface not available", command_id)
+	
+	var scene_root = editor_interface.get_edited_scene_root()
+	if not scene_root:
+		return _send_error(client_id, "No scene is currently open in the editor", command_id)
+	
+	var scene_path: String = scene_root.scene_file_path
+	if scene_path.is_empty():
+		return _send_error(client_id, "Current scene must be saved before it can be run", command_id)
+	
+	editor_interface.play_current_scene()
+	_send_success(client_id, {
+		"status": "running",
+		"scene_path": scene_path
+	}, command_id)
+
+func _run_specific_scene(client_id: int, params: Dictionary, command_id: String) -> void:
+	var editor_interface = _get_editor_interface()
+	if not editor_interface:
+		return _send_error(client_id, "Editor interface not available", command_id)
+	
+	var scene_path: String = params.get("scene_path", "")
+	if scene_path.is_empty():
+		return _send_error(client_id, "scene_path parameter is required", command_id)
+	
+	if not ResourceLoader.exists(scene_path):
+		return _send_error(client_id, "Scene does not exist: %s" % scene_path, command_id)
+	
+	editor_interface.play_custom_scene(scene_path)
+	_send_success(client_id, {
+		"status": "running",
+		"scene_path": scene_path
+	}, command_id)
+
+func _get_editor_interface():
+	if not Engine.has_meta("GodotMCPPlugin"):
+		return null
+	
+	var plugin = Engine.get_meta("GodotMCPPlugin") as EditorPlugin
+	if not plugin:
+		return null
+	
+	return plugin.get_editor_interface()

package/addons/godot_mcp/commands/project_commands.gd.uid

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