godot-mcp-runtime 2.2.3 → 3.0.0

package/dist/scripts/godot_operations.gd

@@ -61,19 +61,13 @@ func _init():
 			export_mesh_library(params)
 		"save_scene":
 			save_scene(params)
-		"get_uid":
-			get_uid(params)
-		"resave_resources":
-			resave_resources(params)
-		# New node operations
-		"delete_node":
-			delete_node(params)
-		"set_node_property":
-			set_node_property(params)
+		# Node operations (always-array)
+		"delete_nodes":
+			delete_nodes(params)
+		"set_node_properties":
+			set_node_properties(params)
 		"get_node_properties":
 			get_node_properties(params)
-		"list_nodes":
-			list_nodes(params)
 		"get_scene_tree":
 			get_scene_tree(params)
 		"attach_script":
@@ -93,10 +87,6 @@ func _init():
 			validate_batch(params)
 		"batch_scene_operations":
 			batch_scene_operations(params)
-		"batch_set_node_properties":
-			batch_set_node_properties(params)
-		"batch_get_node_properties":
-			batch_get_node_properties(params)
 		_:
 			log_error("Unknown operation: " + operation)
 			quit(1)
@@ -220,14 +210,22 @@ func load_scene_instance(scene_path: String):
 
 	return instance
 
-# Helper to find a node by path
+# Helper to find a node by path. Accepts "root", ".", "" (all → scene_root),
+# the actual scene root's name (e.g. "Main"), or a path with either as the first
+# segment (e.g. "root/Button" or "Main/Button"). Bare paths ("Button") resolve
+# normally via get_node_or_null.
 func find_node_by_path(scene_root: Node, node_path: String) -> Node:
-	if node_path == "root" or node_path.is_empty():
+	if node_path == "" or node_path == "." or node_path == "root":
+		return scene_root
+	if node_path == String(scene_root.name):
 		return scene_root
 
 	var path = node_path
-	if path.begins_with("root/"):
-		path = path.substr(5)
+	var first_slash = path.find("/")
+	if first_slash != -1:
+		var first_segment = path.substr(0, first_slash)
+		if first_segment == "root" or first_segment == String(scene_root.name):
+			path = path.substr(first_slash + 1)
 
 	if path.is_empty():
 		return scene_root
@@ -252,6 +250,20 @@ func save_scene_to_path(scene_root: Node, save_path: String) -> bool:
 
 	return true
 
+# Ensure the parent directory of a res:// path exists, creating it recursively
+# if needed. Returns true on success or when the directory already exists.
+func _ensure_res_dir(full_res_path: String) -> bool:
+	var dir_path = full_res_path.get_base_dir()
+	if dir_path == "res://" or dir_path.is_empty():
+		return true
+	var dir = DirAccess.open("res://")
+	if not dir:
+		return false
+	var relative_dir = dir_path.substr(6) if dir_path.begins_with("res://") else dir_path
+	if relative_dir.is_empty() or dir.dir_exists(relative_dir):
+		return true
+	return dir.make_dir_recursive(relative_dir) == OK
+
 # Create a new scene with a specified root node type
 func create_scene(params):
 	printerr("Creating scene: " + params.scene_path)
@@ -272,17 +284,9 @@ func create_scene(params):
 	scene_root.name = "root"
 	scene_root.owner = scene_root
 
-	# Ensure directory exists
-	var scene_dir = full_scene_path.get_base_dir()
-	if scene_dir != "res://" and not scene_dir.is_empty():
-		var dir = DirAccess.open("res://")
-		if dir:
-			var relative_dir = scene_dir.substr(6) if scene_dir.begins_with("res://") else scene_dir
-			if not relative_dir.is_empty() and not dir.dir_exists(relative_dir):
-				var make_error = dir.make_dir_recursive(relative_dir)
-				if make_error != OK:
-					log_error("Failed to create directory: " + relative_dir)
-					quit(1)
+	if not _ensure_res_dir(full_scene_path):
+		log_error("Failed to create directory for scene: " + full_scene_path)
+		quit(1)
 
 	if save_scene_to_path(scene_root, full_scene_path):
 		print("Scene created successfully at: " + params.scene_path)
@@ -318,7 +322,7 @@ func add_node(params):
 		var properties = params.properties
 		for property in properties:
 			log_debug("Setting property: " + property + " = " + str(properties[property]))
-			new_node.set(property, properties[property])
+			new_node.set(property, _coerce_property_value(properties[property]))
 
 	parent.add_child(new_node)
 	new_node.owner = scene_root
@@ -351,6 +355,14 @@ func load_sprite(params):
 	if not texture:
 		log_error("Failed to load texture: " + full_texture_path)
 		quit(1)
+	if not (texture is Texture2D):
+		log_error("Loaded resource is not a Texture2D: " + full_texture_path)
+		quit(1)
+	# A texture without a resource_path is a runtime-only object — PackedScene.pack()
+	# cannot serialize it, so the assignment would silently vanish on save.
+	if texture.resource_path == "":
+		log_error("Texture has no resource_path — likely not imported. Open project in Godot editor once, or run 'godot --headless --editor --quit' to import assets.")
+		quit(1)
 
 	sprite_node.texture = texture
 
@@ -398,22 +410,16 @@ func export_mesh_library(params):
 					mesh_library.set_item_shapes(item_id, [collision_child.shape])
 					break
 
-			if mesh_instance.mesh:
-				mesh_library.set_item_preview(item_id, mesh_instance.mesh)
+			mesh_library.set_item_preview(item_id, mesh_instance.mesh)
 
 			item_id += 1
 
 	if item_id > 0:
 		var full_output_path = normalize_scene_path(params.output_path)
 
-		# Ensure output directory exists
-		var output_dir = full_output_path.get_base_dir()
-		if output_dir != "res://":
-			var dir = DirAccess.open("res://")
-			if dir:
-				var relative_dir = output_dir.substr(6) if output_dir.begins_with("res://") else output_dir
-				if not relative_dir.is_empty() and not dir.dir_exists(relative_dir):
-					dir.make_dir_recursive(relative_dir)
+		if not _ensure_res_dir(full_output_path):
+			log_error("Failed to create directory for MeshLibrary: " + full_output_path)
+			quit(1)
 
 		var error = ResourceSaver.save(mesh_library, full_output_path)
 		if error == OK:
@@ -441,216 +447,97 @@ func save_scene(params):
 		log_error("Failed to save scene")
 		quit(1)
 
-# Find files with a specific extension recursively
-func find_files(path, extension):
-	var files = []
-	var dir = DirAccess.open(path)
-
-	if dir:
-		dir.list_dir_begin()
-		var file_name = dir.get_next()
-
-		while file_name != "":
-			if dir.current_is_dir() and not file_name.begins_with("."):
-				files.append_array(find_files(path + file_name + "/", extension))
-			elif file_name.ends_with(extension):
-				files.append(path + file_name)
-
-			file_name = dir.get_next()
-
-	return files
-
-# Get UID for a specific file
-func get_uid(params):
-	if not params.has("file_path"):
-		log_error("File path is required")
-		quit(1)
-
-	var file_path = normalize_scene_path(params.file_path)
-	printerr("Getting UID for file: " + file_path)
-
-	if not FileAccess.file_exists(file_path):
-		log_error("File does not exist: " + file_path)
-		quit(1)
-
-	var uid_path = file_path + ".uid"
-	var f = FileAccess.open(uid_path, FileAccess.READ)
-
-	if f:
-		var uid_content = f.get_as_text()
-		f.close()
-
-		var result = {
-			"file": file_path,
-			"uid": uid_content.strip_edges(),
-			"exists": true
-		}
-		print(JSON.stringify(result))
-	else:
-		var result = {
-			"file": file_path,
-			"exists": false,
-			"message": "UID file does not exist for this file. Use resave_resources to generate UIDs."
-		}
-		print(JSON.stringify(result))
-
-# Resave all resources to update UID references
-func resave_resources(params):
-	printerr("Resaving all resources to update UID references...")
-
-	var project_path = "res://"
-	if params.has("project_path"):
-		project_path = params.project_path
-		if not project_path.begins_with("res://"):
-			project_path = "res://" + project_path
-		if not project_path.ends_with("/"):
-			project_path += "/"
-
-	var scenes = find_files(project_path, ".tscn")
-	var success_count = 0
-	var error_count = 0
-
-	for scene_path in scenes:
-		var scene = load(scene_path)
-		if scene:
-			var error = ResourceSaver.save(scene, scene_path)
-			if error == OK:
-				success_count += 1
-			else:
-				error_count += 1
-				log_error("Failed to save: " + scene_path)
-		else:
-			error_count += 1
-			log_error("Failed to load: " + scene_path)
-
-	var scripts = find_files(project_path, ".gd") + find_files(project_path, ".shader") + find_files(project_path, ".gdshader")
-	var generated_uids = 0
-
-	for script_path in scripts:
-		var uid_path = script_path + ".uid"
-		var f = FileAccess.open(uid_path, FileAccess.READ)
-		if not f:
-			var res = load(script_path)
-			if res:
-				var error = ResourceSaver.save(res, script_path)
-				if error == OK:
-					generated_uids += 1
-
-	print("Resave operation complete. Scenes: " + str(success_count) + " saved, " + str(error_count) + " errors. UIDs generated: " + str(generated_uids))
-
 # ============================================
-# NEW NODE OPERATIONS
+# NODE OPERATIONS
 # ============================================
 
-# Delete a node from a scene
-func delete_node(params):
-	printerr("Deleting node from scene: " + params.scene_path)
+# Delete one or more nodes from a scene (saves once)
+func delete_nodes(params):
+	printerr("Deleting nodes from scene: " + params.scene_path)
 
 	var scene_root = load_scene_instance(params.scene_path)
 	if not scene_root:
 		quit(1)
 
-	var node = find_node_by_path(scene_root, params.node_path)
-	if not node:
-		log_error("Node not found: " + params.node_path)
-		quit(1)
-
-	if node == scene_root:
-		log_error("Cannot delete the root node")
-		quit(1)
-
-	var parent = node.get_parent()
-	parent.remove_child(node)
-	node.queue_free()
-
-	if save_scene_to_path(scene_root, params.scene_path):
-		print("Node '" + params.node_path + "' deleted successfully")
-	else:
-		log_error("Failed to save scene after deleting node")
-		quit(1)
-
-# Update a single property on a node
-func set_node_property(params):
-	printerr("Updating node property in scene: " + params.scene_path)
-
-	var scene_root = load_scene_instance(params.scene_path)
-	if not scene_root:
-		quit(1)
-
-	var node = find_node_by_path(scene_root, params.node_path)
-	if not node:
-		log_error("Node not found: " + params.node_path)
-		quit(1)
-
-	var property_name = params.property
-	var property_value = _coerce_property_value(params.value)
-
-	log_debug("Setting property '" + property_name + "' to: " + str(property_value))
-
-	node.set(property_name, property_value)
+	var node_paths: Array = params.node_paths
+	var results: Array = []
+	var any_deleted := false
 
-	if save_scene_to_path(scene_root, params.scene_path):
-		print("Property '" + property_name + "' updated successfully on node '" + params.node_path + "'")
-	else:
-		log_error("Failed to save scene after updating property")
-		quit(1)
+	for node_path in node_paths:
+		var entry = {"nodePath": node_path}
+		var node = find_node_by_path(scene_root, node_path)
+		if not node:
+			entry["error"] = "Node not found: " + node_path
+		elif node == scene_root:
+			entry["error"] = "Cannot delete the root node"
+		else:
+			var parent = node.get_parent()
+			parent.remove_child(node)
+			node.queue_free()
+			entry["success"] = true
+			any_deleted = true
+		results.append(entry)
+
+	if any_deleted:
+		if not save_scene_to_path(scene_root, params.scene_path):
+			print(JSON.stringify({"error": "Failed to save scene after deleting nodes", "results": results}))
+			return
 
-# Get all properties of a specific node
-func get_node_properties(params):
-	printerr("Getting node properties from scene: " + params.scene_path)
+	print(JSON.stringify({"results": results}))
 
+# Update one or more node properties in a single headless process (saves once)
+func set_node_properties(params: Dictionary) -> void:
 	var scene_root = load_scene_instance(params.scene_path)
 	if not scene_root:
-		quit(1)
-
-	var node = find_node_by_path(scene_root, params.node_path)
-	if not node:
-		log_error("Node not found: " + params.node_path)
-		quit(1)
+		print(JSON.stringify({"error": "Failed to load scene: " + params.scene_path, "results": []}))
+		return
 
-	var changed_only = params.has("changed_only") and params.changed_only
-	var properties = _collect_node_properties(node, changed_only)
+	var abort_on_error = params.get("abort_on_error", false)
+	var results: Array = []
+	var any_set := false
 
-	var result = {
-		"nodePath": params.node_path,
-		"nodeType": node.get_class(),
-		"properties": properties
-	}
+	for update in params.updates:
+		var result = {"nodePath": update.node_path, "property": update.property}
+		var node = find_node_by_path(scene_root, update.node_path)
+		if node == null:
+			result["error"] = "Node not found: " + update.node_path
+		elif not (update.property in node):
+			result["error"] = "Property '%s' does not exist on node of type '%s'" % [update.property, node.get_class()]
+		else:
+			node.set(update.property, _coerce_property_value(update.value))
+			result["success"] = true
+			any_set = true
+		results.append(result)
+		if abort_on_error and result.has("error"):
+			break
 
-	print(JSON.stringify(result))
+	if any_set:
+		if not save_scene_to_path(scene_root, params.scene_path):
+			print(JSON.stringify({"error": "Failed to save scene after updates", "results": results}))
+			return
 
-# List all child nodes under a parent
-func list_nodes(params):
-	printerr("Listing nodes in scene: " + params.scene_path)
+	print(JSON.stringify({"results": results}))
 
+# Get properties from one or more nodes in a single headless process (loads scene once)
+func get_node_properties(params: Dictionary) -> void:
 	var scene_root = load_scene_instance(params.scene_path)
 	if not scene_root:
-		quit(1)
-
-	var parent_path = "root"
-	if params.has("parent_path"):
-		parent_path = params.parent_path
-
-	var parent = find_node_by_path(scene_root, parent_path)
-	if not parent:
-		log_error("Parent node not found: " + parent_path)
-		quit(1)
+		print(JSON.stringify({"error": "Failed to load scene: " + params.scene_path, "results": []}))
+		return
 
-	var children = []
-	for child in parent.get_children():
-		children.append({
-			"name": child.name,
-			"type": child.get_class(),
-			"childCount": child.get_child_count()
-		})
+	var results: Array = []
 
-	var result = {
-		"parentPath": parent_path,
-		"parentType": parent.get_class(),
-		"children": children
-	}
+	for node_spec in params.nodes:
+		var node_path = node_spec.get("node_path", "")
+		var changed_only = node_spec.get("changed_only", false)
+		var node = find_node_by_path(scene_root, node_path)
+		if node == null:
+			results.append({"nodePath": node_path, "error": "Node not found"})
+		else:
+			var props = _collect_node_properties(node, changed_only)
+			results.append({"nodePath": node_path, "nodeType": node.get_class(), "properties": props})
 
-	print(JSON.stringify(result))
+	print(JSON.stringify({"results": results}))
 
 # Get full hierarchical tree structure of a scene
 func get_scene_tree(params):
@@ -660,11 +547,18 @@ func get_scene_tree(params):
 	if not scene_root:
 		quit(1)
 
+	var tree_root = scene_root
+	if params.has("parent_path") and params.parent_path:
+		tree_root = find_node_by_path(scene_root, params.parent_path)
+		if not tree_root:
+			log_error("Parent node not found: " + str(params.parent_path))
+			quit(1)
+
 	var max_depth = -1
 	if params.has("max_depth"):
 		max_depth = int(params.max_depth)
 
-	var tree = build_tree_recursive(scene_root, "", 0, max_depth)
+	var tree = build_tree_recursive(tree_root, "", 0, max_depth)
 	print(JSON.stringify(tree))
 
 func build_tree_recursive(node: Node, path: String, depth: int = 0, max_depth: int = -1) -> Dictionary:
@@ -676,10 +570,9 @@ func build_tree_recursive(node: Node, path: String, depth: int = 0, max_depth: i
 			children.append(build_tree_recursive(child, node_path, depth + 1, max_depth))
 
 	var script_path = ""
-	if node.get_script():
-		var script = node.get_script()
-		if script.resource_path:
-			script_path = script.resource_path
+	var script = node.get_script()
+	if script and script.resource_path:
+		script_path = script.resource_path
 
 	return {
 		"name": node.name,
@@ -822,7 +715,9 @@ func connect_signal(params):
 		log_error("Method does not exist: " + params.method + " on " + target.get_class())
 		quit(1)
 
-	var err = source.connect(params.signal, Callable(target, params.method))
+	# CONNECT_PERSIST is required for the connection to be serialized into the
+	# packed scene; without it the connection is runtime-only and disappears on save.
+	var err = source.connect(params.signal, Callable(target, params.method), CONNECT_PERSIST)
 	if err != OK:
 		log_error("Failed to connect signal: " + str(err))
 		quit(1)
@@ -976,7 +871,7 @@ func _batch_add_node(scene_root: Node, op: Dictionary) -> String:
 	new_node.name = op.node_name
 	if op.has("properties"):
 		for property in op.properties:
-			new_node.set(property, op.properties[property])
+			new_node.set(property, _coerce_property_value(op.properties[property]))
 	parent.add_child(new_node)
 	new_node.owner = scene_root
 	return ""
@@ -995,6 +890,10 @@ func _batch_load_sprite(scene_root: Node, op: Dictionary) -> String:
 	var texture = load(normalize_scene_path(op.texture_path))
 	if not texture:
 		return "Failed to load texture: " + op.texture_path
+	if not (texture is Texture2D):
+		return "Loaded resource is not a Texture2D: " + op.texture_path
+	if texture.resource_path == "":
+		return "Texture has no resource_path — likely not imported. Open project in Godot editor once, or run 'godot --headless --editor --quit' to import assets."
 	sprite_node.texture = texture
 	return ""
 
@@ -1067,51 +966,3 @@ func batch_scene_operations(params: Dictionary) -> void:
 		save_scene_to_path(scene_cache[scene_path], scene_path)
 
 	print(JSON.stringify({"results": results}))
-
-# Update multiple node properties in a single headless process (loads and saves scene once)
-func batch_set_node_properties(params: Dictionary) -> void:
-	var scene_root = load_scene_instance(params.scene_path)
-	if not scene_root:
-		print(JSON.stringify({"error": "Failed to load scene: " + params.scene_path, "results": []}))
-		return
-
-	var abort_on_error = params.get("abort_on_error", false)
-	var results: Array = []
-
-	for update in params.updates:
-		var result = {"nodePath": update.node_path, "property": update.property}
-		var node = find_node_by_path(scene_root, update.node_path)
-		if node == null:
-			result["error"] = "Node not found: " + update.node_path
-		else:
-			node.set(update.property, _coerce_property_value(update.value))
-			result["success"] = true
-		results.append(result)
-		if abort_on_error and result.has("error"):
-			break
-
-	if save_scene_to_path(scene_root, params.scene_path):
-		print(JSON.stringify({"results": results}))
-	else:
-		print(JSON.stringify({"error": "Failed to save scene after batch updates", "partial_results": results}))
-
-# Get properties from multiple nodes in a single headless process (loads scene once)
-func batch_get_node_properties(params: Dictionary) -> void:
-	var scene_root = load_scene_instance(params.scene_path)
-	if not scene_root:
-		print(JSON.stringify({"error": "Failed to load scene: " + params.scene_path, "results": []}))
-		return
-
-	var results: Array = []
-
-	for node_spec in params.nodes:
-		var node_path = node_spec.get("node_path", "")
-		var changed_only = node_spec.get("changed_only", false)
-		var node = find_node_by_path(scene_root, node_path)
-		if node == null:
-			results.append({"nodePath": node_path, "error": "Node not found"})
-		else:
-			var props = _collect_node_properties(node, changed_only)
-			results.append({"nodePath": node_path, "nodeType": node.get_class(), "properties": props})
-
-	print(JSON.stringify({"results": results}))