@baixfeng/godot-mcp-cli 1.0.11

package/addons/godot_mcp/utils/resource_utils.gd

@@ -0,0 +1,81 @@
+@tool
+class_name ResourceUtils
+extends RefCounted
+
+# Load a resource safely, returning null if it fails
+static func safe_load(path: String) -> Resource:
+	if not ResourceLoader.exists(path):
+		push_error("Resource does not exist: " + path)
+		return null
+	
+	var res = ResourceLoader.load(path)
+	if not res:
+		push_error("Failed to load resource: " + path)
+		return null
+	
+	return res
+
+# Save a resource safely, returning true if successful
+static func safe_save(resource: Resource, path: String) -> bool:
+	if not resource:
+		push_error("Cannot save null resource")
+		return false
+	
+	# Make sure directory exists
+	var dir_path = path.get_base_dir()
+	if not DirAccess.dir_exists_absolute(dir_path):
+		var err = DirAccess.make_dir_recursive_absolute(dir_path)
+		if err != OK:
+			push_error("Failed to create directory: " + dir_path)
+			return false
+	
+	var result = ResourceSaver.save(resource, path)
+	if result != OK:
+		push_error("Failed to save resource: " + path)
+		return false
+	
+	return true
+
+# Create a new resource instance by type name
+static func create_resource(type_name: String) -> Resource:
+	if not ClassDB.class_exists(type_name):
+		push_error("Class does not exist: " + type_name)
+		return null
+	
+	if not ClassDB.is_parent_class(type_name, "Resource"):
+		push_error("Class is not a Resource: " + type_name)
+		return null
+	
+	if not ClassDB.can_instantiate(type_name):
+		push_error("Cannot instantiate Resource class: " + type_name)
+		return null
+	
+	return ClassDB.instantiate(type_name)
+
+# Get a list of all resource types that inherit from a base class
+static func get_resource_types(base_class: String = "Resource") -> Array[String]:
+	var result: Array[String] = []
+	
+	for class_type in ClassDB.get_class_list():
+		if ClassDB.is_parent_class(class_type, base_class) and ClassDB.can_instantiate(class_type):
+			result.append(class_type)
+	
+	return result
+
+# Convert a resource to a JSON-compatible dictionary
+static func resource_to_dict(resource: Resource) -> Dictionary:
+	var result = {
+		"resource_path": resource.resource_path,
+		"resource_name": resource.resource_name,
+		"type": resource.get_class(),
+		"properties": {}
+	}
+	
+	# Get properties
+	var property_list = resource.get_property_list()
+	for prop in property_list:
+		var prop_name = prop["name"]
+		if not prop_name.begins_with("_") and prop_name != "resource_path" and prop_name != "resource_name":
+			result["properties"][prop_name] = resource.get(prop_name)
+	
+	return result

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

@@ -0,0 +1 @@
+uid://3jnu2dy6wa8a

package/addons/godot_mcp/utils/script_utils.gd

@@ -0,0 +1,114 @@
+@tool
+class_name ScriptUtils
+extends RefCounted
+
+# Create a new GDScript with basic template content
+static func create_new_script(class_name_str: String = "", extends_type: String = "Node") -> GDScript:
+	var script = GDScript.new()
+	var content = ""
+	
+	if not class_name_str.is_empty():
+		content += "class_name " + class_name_str + "\n"
+	
+	content += "extends " + extends_type + "\n\n"
+	content += "func _ready():\n"
+	content += "\tpass\n"
+	
+	script.source_code = content
+	return script
+
+# Create a new script file with basic template content
+static func create_script_file(path: String, class_name_str: String = "", extends_type: String = "Node") -> bool:
+	# Make sure directory exists
+	var dir_path = path.get_base_dir()
+	if not DirAccess.dir_exists_absolute(dir_path):
+		var err = DirAccess.make_dir_recursive_absolute(dir_path)
+		if err != OK:
+			push_error("Failed to create directory: " + dir_path)
+			return false
+	
+	var content = ""
+	
+	if not class_name_str.is_empty():
+		content += "class_name " + class_name_str + "\n"
+	
+	content += "extends " + extends_type + "\n\n"
+	content += "func _ready():\n"
+	content += "\tpass\n"
+	
+	var file = FileAccess.open(path, FileAccess.WRITE)
+	if file == null:
+		push_error("Failed to open file for writing: " + path)
+		return false
+	
+	file.store_string(content)
+	file = null  # Close the file
+	
+	return true
+
+# Parse a script file and extract its class name and base class
+static func get_script_info(path: String) -> Dictionary:
+	var result = {
+		"class_name": "",
+		"extends": "",
+		"path": path
+	}
+	
+	var file = FileAccess.open(path, FileAccess.READ)
+	if file == null:
+		push_error("Failed to open file for reading: " + path)
+		return result
+	
+	var content = file.get_as_text()
+	file = null  # Close the file
+	
+	# Find class_name
+	var class_name_regex = RegEx.new()
+	class_name_regex.compile("class_name\\s+([A-Za-z0-9_]+)")
+	var matches = class_name_regex.search(content)
+	if matches:
+		result["class_name"] = matches.get_string(1)
+	
+	# Find extends
+	var extends_regex = RegEx.new()
+	extends_regex.compile("extends\\s+([A-Za-z0-9_]+)")
+	matches = extends_regex.search(content)
+	if matches:
+		result["extends"] = matches.get_string(1)
+	
+	return result
+
+# Extract all method names from a script
+static func get_script_methods(path: String) -> Array:
+	var methods = []
+	
+	var file = FileAccess.open(path, FileAccess.READ)
+	if file == null:
+		push_error("Failed to open file for reading: " + path)
+		return methods
+	
+	var content = file.get_as_text()
+	file = null  # Close the file
+	
+	var method_regex = RegEx.new()
+	method_regex.compile("func\\s+([A-Za-z0-9_]+)\\s*\\(")
+	
+	var matches = method_regex.search_all(content)
+	for match_idx in range(matches.size()):
+		methods.append(matches[match_idx].get_string(1))
+	
+	return methods
+
+# Apply a script to a node
+static func apply_script_to_node(node: Node, script_path: String) -> bool:
+	if not node:
+		push_error("Node is null")
+		return false
+	
+	var script = ResourceLoader.load(script_path)
+	if not script:
+		push_error("Failed to load script: " + script_path)
+		return false
+	
+	node.set_script(script)
+	return true

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

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

package/addons/godot_mcp/websocket_server.gd

@@ -0,0 +1,197 @@
+@tool
+class_name MCPWebSocketServer
+extends Node
+
+signal client_connected(id)
+signal client_disconnected(id)
+signal command_received(client_id, command)
+
+var tcp_server = TCPServer.new()
+var peers = {}
+var _port = 9080
+
+func _ready():
+	set_process(false)
+
+func _process(_delta):
+	poll()
+
+func is_server_active() -> bool:
+	return tcp_server.is_listening()
+
+func start_server() -> int:
+	if is_server_active():
+		return ERR_ALREADY_IN_USE
+	
+	# Configure TCP server
+	var err = tcp_server.listen(_port, "127.0.0.1")
+	if err == OK:
+		set_process(true)
+		print("MCP WebSocket server started on port %d" % _port)
+	else:
+		print("Failed to start MCP WebSocket server: %d" % err)
+	
+	return err
+
+func stop_server() -> void:
+	if is_server_active():
+		# Close all client connections properly
+		for client_id in peers.keys():
+			if peers[client_id] != null:
+				peers[client_id].close()
+		peers.clear()
+		
+		# Stop TCP server
+		tcp_server.stop()
+		set_process(false)
+		print("MCP WebSocket server stopped")
+
+func poll() -> void:
+	if not tcp_server.is_listening():
+		return
+	
+	# Handle new connections
+	if tcp_server.is_connection_available():
+		var tcp = tcp_server.take_connection()
+		if tcp == null:
+			print("Failed to take TCP connection")
+			return
+		
+		tcp.set_no_delay(true)  # Important for WebSocket
+		
+		print("New TCP connection accepted")
+		var ws = WebSocketPeer.new()
+		
+		# Configure WebSocket peer
+		ws.inbound_buffer_size = 64 * 1024 * 1024  # 64MB buffer
+		ws.outbound_buffer_size = 64 * 1024 * 1024  # 64MB buffer
+		ws.max_queued_packets = 4096
+		
+		# Accept the stream
+		var err = ws.accept_stream(tcp)
+		if err != OK:
+			print("Failed to accept WebSocket stream: ", err)
+			return
+		
+		# Generate client ID and store peer
+		var client_id = randi() % (1 << 30) + 1
+		peers[client_id] = ws
+		print("WebSocket connection setup for client: ", client_id)
+	
+	# Process existing connections
+	var to_remove = []
+	
+	for client_id in peers:
+		var peer = peers[client_id]
+		if peer == null:
+			to_remove.append(client_id)
+			continue
+			
+		peer.poll()
+		var state = peer.get_ready_state()
+		
+		match state:
+			WebSocketPeer.STATE_OPEN:
+				# Process any available packets
+				while peer.get_available_packet_count() > 0:
+					var packet = peer.get_packet()
+					_handle_packet(client_id, packet)
+					
+			WebSocketPeer.STATE_CONNECTING:
+				print("Client %d still connecting..." % client_id)
+				
+			WebSocketPeer.STATE_CLOSING:
+				print("Client %d closing connection..." % client_id)
+				
+			WebSocketPeer.STATE_CLOSED:
+				print("Client %d connection closed. Code: %d, Reason: %s" % [
+					client_id,
+					peer.get_close_code(),
+					peer.get_close_reason()
+				])
+				emit_signal("client_disconnected", client_id)
+				to_remove.append(client_id)
+	
+	# Remove disconnected clients
+	for client_id in to_remove:
+		var peer = peers[client_id]
+		if peer != null:
+			peer.close()
+		peers.erase(client_id)
+
+func _handle_packet(client_id: int, packet: PackedByteArray) -> void:
+	var text = packet.get_string_from_utf8()
+	var json = JSON.new()
+	var parse_result = json.parse(text)
+	
+	if parse_result == OK:
+		var data = json.get_data()
+		
+		# Handle ping-pong for FastMCP
+		if data.has("method") and data["method"] == "ping":
+			var response = {
+				"jsonrpc": "2.0",
+				"id": data.get("id", 0),
+				"result": "pong"
+			}
+			send_response(client_id, response)
+			return
+			
+		print("Received command from client %d: %s" % [client_id, data])
+		emit_signal("command_received", client_id, data)
+	else:
+		print("Error parsing JSON from client %d: %s at line %d" % 
+			[client_id, json.get_error_message(), json.get_error_line()])
+
+func send_response(client_id: int, response: Dictionary) -> int:
+	if not peers.has(client_id):
+		print("Error: Client %d not found" % client_id)
+		return ERR_DOES_NOT_EXIST
+	
+	var peer = peers[client_id]
+	if peer == null:
+		print("Error: Peer is null for client %d" % client_id)
+		return ERR_INVALID_PARAMETER
+		
+	if peer.get_ready_state() != WebSocketPeer.STATE_OPEN:
+		print("Error: Client %d connection not open" % client_id)
+		return ERR_UNAVAILABLE
+	
+	var json_text = JSON.stringify(response)
+	var result = peer.send_text(json_text)
+	
+	if result != OK:
+		print("Error sending response to client %d: %d" % [client_id, result])
+	
+	return result
+
+func send_event(client_id: int, event: Dictionary) -> int:
+	if not peers.has(client_id):
+		return ERR_DOES_NOT_EXIST
+
+	var peer = peers[client_id]
+	if peer == null or peer.get_ready_state() != WebSocketPeer.STATE_OPEN:
+		return ERR_UNAVAILABLE
+
+	var payload := event.duplicate(true)
+	if not payload.has("event"):
+		payload["event"] = "unknown"
+
+	var json_text = JSON.stringify(payload)
+	return peer.send_text(json_text)
+
+func broadcast_event(event: Dictionary) -> void:
+	for client_id in peers.keys():
+		send_event(client_id, event)
+
+func set_port(new_port: int) -> void:
+	if is_server_active():
+		push_error("Cannot change port while server is active")
+		return
+	_port = new_port
+
+func get_port() -> int:
+	return _port
+
+func get_client_count() -> int:
+	return peers.size()

package/addons/godot_mcp/websocket_server.gd.uid

@@ -0,0 +1 @@
+uid://5yoxi2gkygu4

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};