@satelliteoflove/godot-mcp 2.2.0 → 2.4.0

package/addon/commands/screenshot_commands.gd

@@ -0,0 +1,130 @@
+@tool
+extends MCPBaseCommand
+class_name MCPScreenshotCommands
+
+const DEFAULT_MAX_WIDTH := 1920
+const SCREENSHOT_TIMEOUT := 5.0
+
+var _screenshot_result: Dictionary = {}
+var _screenshot_pending: bool = false
+
+
+func get_commands() -> Dictionary:
+	return {
+		"capture_game_screenshot": capture_game_screenshot,
+		"capture_editor_screenshot": capture_editor_screenshot
+	}
+
+
+func capture_game_screenshot(params: Dictionary) -> Dictionary:
+	if not EditorInterface.is_playing_scene():
+		return _error("NOT_RUNNING", "No game is currently running. Use run_project first.")
+
+	var max_width: int = params.get("max_width", DEFAULT_MAX_WIDTH)
+
+	var debugger_plugin = _plugin.get_debugger_plugin() if _plugin else null
+	if debugger_plugin == null:
+		return _error("NO_DEBUGGER", "Debugger plugin not available")
+
+	if not debugger_plugin.has_active_session():
+		return _error("NO_SESSION", "No active debug session. Game may not have MCPGameBridge autoload.")
+
+	_screenshot_pending = true
+	_screenshot_result = {}
+
+	debugger_plugin.screenshot_received.connect(_on_screenshot_received, CONNECT_ONE_SHOT)
+	debugger_plugin.request_screenshot(max_width)
+
+	var start_time := Time.get_ticks_msec()
+	while _screenshot_pending:
+		await Engine.get_main_loop().process_frame
+		if (Time.get_ticks_msec() - start_time) / 1000.0 > SCREENSHOT_TIMEOUT:
+			_screenshot_pending = false
+			if debugger_plugin.screenshot_received.is_connected(_on_screenshot_received):
+				debugger_plugin.screenshot_received.disconnect(_on_screenshot_received)
+			return _error("TIMEOUT", "Screenshot request timed out")
+
+	return _screenshot_result
+
+
+func _on_screenshot_received(success: bool, image_base64: String, width: int, height: int, error: String) -> void:
+	_screenshot_pending = false
+	if success:
+		_screenshot_result = _success({
+			"image_base64": image_base64,
+			"width": width,
+			"height": height
+		})
+	else:
+		_screenshot_result = _error("CAPTURE_FAILED", error)
+
+
+func capture_editor_screenshot(params: Dictionary) -> Dictionary:
+	var viewport_type: String = params.get("viewport", "")
+	var max_width: int = params.get("max_width", DEFAULT_MAX_WIDTH)
+
+	var viewport: SubViewport = null
+
+	if viewport_type == "2d":
+		viewport = _find_2d_viewport()
+	elif viewport_type == "3d":
+		viewport = _find_3d_viewport()
+	else:
+		viewport = _find_active_viewport()
+
+	if viewport == null:
+		return _error("NO_VIEWPORT", "Could not find editor viewport")
+
+	var image := viewport.get_texture().get_image()
+	return _process_and_encode_image(image, max_width)
+
+
+func _process_and_encode_image(image: Image, max_width: int) -> Dictionary:
+	if image == null:
+		return _error("CAPTURE_FAILED", "Failed to capture image from viewport")
+
+	if max_width > 0 and image.get_width() > max_width:
+		var scale_factor := float(max_width) / float(image.get_width())
+		var new_height := int(image.get_height() * scale_factor)
+		image.resize(max_width, new_height, Image.INTERPOLATE_LANCZOS)
+
+	var png_buffer := image.save_png_to_buffer()
+	var base64 := Marshalls.raw_to_base64(png_buffer)
+
+	return _success({
+		"image_base64": base64,
+		"width": image.get_width(),
+		"height": image.get_height()
+	})
+
+
+func _find_active_viewport() -> SubViewport:
+	var viewport := _find_3d_viewport()
+	if viewport:
+		return viewport
+	return _find_2d_viewport()
+
+
+func _find_2d_viewport() -> SubViewport:
+	var editor_main := EditorInterface.get_editor_main_screen()
+	return _find_viewport_in_tree(editor_main, "2D")
+
+
+func _find_3d_viewport() -> SubViewport:
+	var editor_main := EditorInterface.get_editor_main_screen()
+	return _find_viewport_in_tree(editor_main, "3D")
+
+
+func _find_viewport_in_tree(node: Node, hint: String) -> SubViewport:
+	if node is SubViewportContainer:
+		var container := node as SubViewportContainer
+		for child in container.get_children():
+			if child is SubViewport:
+				return child as SubViewport
+
+	for child in node.get_children():
+		var result := _find_viewport_in_tree(child, hint)
+		if result:
+			return result
+
+	return null

package/addon/commands/screenshot_commands.gd.uid

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

package/addon/commands/script_commands.gd

@@ -0,0 +1,156 @@
+@tool
+extends MCPBaseCommand
+class_name MCPScriptCommands
+
+
+func get_commands() -> Dictionary:
+	return {
+		"read_script": read_script,
+		"get_current_script": get_current_script,
+		"create_script": create_script,
+		"edit_script": edit_script,
+		"attach_script": attach_script,
+		"detach_script": detach_script
+	}
+
+
+func read_script(params: Dictionary) -> Dictionary:
+	var script_path: String = params.get("script_path", "")
+	if script_path.is_empty():
+		return _error("INVALID_PARAMS", "script_path is required")
+
+	if not FileAccess.file_exists(script_path):
+		return _error("FILE_NOT_FOUND", "Script file not found: %s" % script_path)
+
+	var file := FileAccess.open(script_path, FileAccess.READ)
+	if not file:
+		return _error("READ_FAILED", "Failed to read script: %s" % script_path)
+
+	var content := file.get_as_text()
+	file.close()
+
+	return _success({"content": content})
+
+
+func get_current_script(_params: Dictionary) -> Dictionary:
+	var script_editor := EditorInterface.get_script_editor()
+	if not script_editor:
+		return _success({"path": null, "content": null})
+
+	var current_script := script_editor.get_current_script()
+	if not current_script:
+		return _success({"path": null, "content": null})
+
+	return _success({
+		"path": current_script.resource_path,
+		"content": current_script.source_code
+	})
+
+
+func create_script(params: Dictionary) -> Dictionary:
+	var script_path: String = params.get("script_path", "")
+	var content: String = params.get("content", "")
+	var attach_to: String = params.get("attach_to", "")
+
+	if script_path.is_empty():
+		return _error("INVALID_PARAMS", "script_path is required")
+	if content.is_empty():
+		return _error("INVALID_PARAMS", "content is required")
+
+	var dir_path := script_path.get_base_dir()
+	if not MCPUtils.dir_exists(dir_path):
+		var err := MCPUtils.ensure_dir_exists(dir_path)
+		if err != OK:
+			return _error("DIR_CREATE_FAILED", "Failed to create directory: %s" % dir_path)
+
+	var file := FileAccess.open(script_path, FileAccess.WRITE)
+	if not file:
+		return _error("WRITE_FAILED", "Failed to create script: %s" % script_path)
+
+	file.store_string(content)
+	file.close()
+
+	EditorInterface.get_resource_filesystem().scan()
+
+	if not attach_to.is_empty():
+		var attach_result := attach_script({"node_path": attach_to, "script_path": script_path})
+		if attach_result["status"] == "error":
+			return attach_result
+
+	return _success({"path": script_path})
+
+
+func edit_script(params: Dictionary) -> Dictionary:
+	var script_path: String = params.get("script_path", "")
+	var content: String = params.get("content", "")
+
+	if script_path.is_empty():
+		return _error("INVALID_PARAMS", "script_path is required")
+	if content.is_empty():
+		return _error("INVALID_PARAMS", "content is required")
+
+	if not FileAccess.file_exists(script_path):
+		return _error("FILE_NOT_FOUND", "Script file not found: %s" % script_path)
+
+	var file := FileAccess.open(script_path, FileAccess.WRITE)
+	if not file:
+		return _error("WRITE_FAILED", "Failed to write script: %s" % script_path)
+
+	file.store_string(content)
+	file.close()
+
+	EditorInterface.get_resource_filesystem().scan()
+
+	var script := load(script_path) as Script
+	if script:
+		script.reload()
+
+	return _success({"path": script_path})
+
+
+func attach_script(params: Dictionary) -> Dictionary:
+	var node_path: String = params.get("node_path", "")
+	var script_path: String = params.get("script_path", "")
+
+	if node_path.is_empty():
+		return _error("INVALID_PARAMS", "node_path is required")
+	if script_path.is_empty():
+		return _error("INVALID_PARAMS", "script_path is required")
+
+	var node := _get_node(node_path)
+	if not node:
+		return _error("NODE_NOT_FOUND", "Node not found: %s" % node_path)
+
+	if not FileAccess.file_exists(script_path):
+		return _error("FILE_NOT_FOUND", "Script file not found: %s" % script_path)
+
+	var script := load(script_path) as Script
+	if not script:
+		return _error("LOAD_FAILED", "Failed to load script: %s" % script_path)
+
+	node.set_script(script)
+
+	EditorInterface.get_resource_filesystem().scan()
+	script.reload()
+
+	if node.get_script() != script:
+		return _error("ATTACH_FAILED", "Script attachment did not persist")
+
+	return _success({"node_path": str(node.get_path()), "script_path": script_path})
+
+
+func detach_script(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)
+
+	node.set_script(null)
+
+	return _success({})
+
+

package/addon/commands/script_commands.gd.uid

@@ -0,0 +1 @@
+uid://6t4dbbx8421b

package/addon/commands/selection_commands.gd

@@ -0,0 +1,170 @@
+@tool
+extends MCPBaseCommand
+class_name MCPSelectionCommands
+
+
+func get_commands() -> Dictionary:
+	return {
+		"get_editor_state": get_editor_state,
+		"get_selected_nodes": get_selected_nodes,
+		"select_node": select_node,
+		"set_2d_viewport": set_2d_viewport
+	}
+
+
+func get_editor_state(_params: Dictionary) -> Dictionary:
+	var root := EditorInterface.get_edited_scene_root()
+	var open_scenes := EditorInterface.get_open_scenes()
+
+	var main_screen := _get_current_main_screen()
+
+	var result := {
+		"current_scene": root.scene_file_path if root else null,
+		"is_playing": EditorInterface.is_playing_scene(),
+		"godot_version": Engine.get_version_info()["string"],
+		"open_scenes": Array(open_scenes),
+		"main_screen": main_screen
+	}
+
+	if main_screen == "3D":
+		var camera_info := _get_editor_camera_info()
+		if not camera_info.is_empty():
+			result["camera"] = camera_info
+	elif main_screen == "2D":
+		var viewport_2d_info := _get_editor_2d_viewport_info()
+		if not viewport_2d_info.is_empty():
+			result["viewport_2d"] = viewport_2d_info
+
+	return _success(result)
+
+
+func _get_editor_camera_info() -> Dictionary:
+	var viewport := EditorInterface.get_editor_viewport_3d(0)
+	if not viewport:
+		return {}
+
+	var camera := viewport.get_camera_3d()
+	if not camera:
+		return {}
+
+	var pos: Vector3 = camera.global_position
+	var rot: Vector3 = camera.global_rotation
+	var forward: Vector3 = -camera.global_transform.basis.z
+
+	var info := {
+		"position": {"x": pos.x, "y": pos.y, "z": pos.z},
+		"rotation": {"x": rot.x, "y": rot.y, "z": rot.z},
+		"forward": {"x": forward.x, "y": forward.y, "z": forward.z},
+		"fov": camera.fov,
+		"near": camera.near,
+		"far": camera.far,
+		"projection": "orthogonal" if camera.projection == Camera3D.PROJECTION_ORTHOGONAL else "perspective",
+	}
+
+	if camera.projection == Camera3D.PROJECTION_ORTHOGONAL:
+		info["size"] = camera.size
+
+	return info
+
+
+func _get_editor_2d_viewport_info() -> Dictionary:
+	var viewport := EditorInterface.get_editor_viewport_2d()
+	if not viewport:
+		return {}
+
+	var transform := viewport.global_canvas_transform
+	var zoom: float = transform.x.x
+	var offset: Vector2 = -transform.origin / zoom
+
+	var size := viewport.size
+
+	return {
+		"center": {"x": offset.x + size.x / zoom / 2, "y": offset.y + size.y / zoom / 2},
+		"zoom": zoom,
+		"size": {"width": int(size.x), "height": int(size.y)}
+	}
+
+
+func set_2d_viewport(params: Dictionary) -> Dictionary:
+	var viewport := EditorInterface.get_editor_viewport_2d()
+	if not viewport:
+		return _error("NO_VIEWPORT", "Could not access 2D editor viewport")
+
+	var center_x: float = params.get("center_x", 0.0)
+	var center_y: float = params.get("center_y", 0.0)
+	var zoom: float = params.get("zoom", 1.0)
+
+	if zoom <= 0:
+		return _error("INVALID_PARAMS", "zoom must be positive")
+
+	var size := viewport.size
+	var offset := Vector2(center_x - size.x / zoom / 2, center_y - size.y / zoom / 2)
+	var origin := -offset * zoom
+
+	var transform := Transform2D(Vector2(zoom, 0), Vector2(0, zoom), origin)
+	viewport.global_canvas_transform = transform
+
+	return _success({
+		"center": {"x": center_x, "y": center_y},
+		"zoom": zoom
+	})
+
+
+const MAIN_SCREEN_PATTERNS := {
+	"2D": ["CanvasItemEditor", "2D"],
+	"3D": ["Node3DEditor", "3D"],
+	"Script": ["ScriptEditor", "Script"],
+	"AssetLib": ["AssetLib", "Asset"],
+}
+
+
+func _get_current_main_screen() -> String:
+	var main_screen := EditorInterface.get_editor_main_screen()
+	if not main_screen:
+		return "unknown"
+
+	for child in main_screen.get_children():
+		if child.visible and child is Control:
+			var cls := child.get_class()
+			var node_name := child.name
+
+			for screen_name in MAIN_SCREEN_PATTERNS:
+				var patterns: Array = MAIN_SCREEN_PATTERNS[screen_name]
+				if patterns[0] in cls or patterns[1] in node_name:
+					return screen_name
+
+	return "unknown"
+
+
+func get_selected_nodes(_params: Dictionary) -> Dictionary:
+	var selection := EditorInterface.get_selection()
+	var root := EditorInterface.get_edited_scene_root()
+	var selected: Array[String] = []
+
+	for node in selection.get_selected_nodes():
+		if root and root.is_ancestor_of(node):
+			# Build clean path relative to scene root
+			var relative_path := root.get_path_to(node)
+			var usable_path := "/root/" + root.name
+			if relative_path != NodePath("."):
+				usable_path += "/" + str(relative_path)
+			selected.append(usable_path)
+		elif node == root:
+			selected.append("/root/" + root.name)
+
+	return _success({"selected": selected})
+
+
+func select_node(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 selection := EditorInterface.get_selection()
+	selection.clear()
+	selection.add_node(node)
+	return _success({})

package/addon/commands/selection_commands.gd.uid

@@ -0,0 +1 @@
+uid://20vnciu1es3c

package/addon/commands/system_commands.gd

@@ -0,0 +1,29 @@
+@tool
+extends MCPBaseCommand
+class_name MCPSystemCommands
+
+
+func get_commands() -> Dictionary:
+	return {
+		"mcp_handshake": mcp_handshake,
+	}
+
+
+func mcp_handshake(params: Dictionary) -> Dictionary:
+	var server_version: String = params.get("server_version", "unknown")
+
+	return _success({
+		"addon_version": _get_addon_version(),
+		"godot_version": Engine.get_version_info()["string"],
+		"project_path": ProjectSettings.globalize_path("res://"),
+		"project_name": ProjectSettings.get_setting("application/config/name", ""),
+		"server_version_received": server_version
+	})
+
+
+func _get_addon_version() -> String:
+	var config := ConfigFile.new()
+	var err := config.load("res://addons/godot_mcp/plugin.cfg")
+	if err == OK:
+		return config.get_value("plugin", "version", "unknown")
+	return "unknown"