@satelliteoflove/godot-mcp 3.23.1 → 4.0.1

package/README.md

@@ -24,12 +24,12 @@ The pieces that make that possible, and that you won't find elsewhere:
 Here's what that looks like when an agent tests a boss fight:
 
 ```text
-godot_editor        run frozen=true           # boot with game time frozen at frame 0
+godot_editor_edit   run frozen=true           # boot with game time frozen at frame 0
 godot_exec          GameState.wave = 3        # set up the scenario worth testing
 godot_game_time     step_until "tree.get_nodes_in_group('boss').size() >= 1"
 godot_runtime_state digest                    # exact positions and state — no pixels, no guessing
 godot_game_time     step 500ms + dodge input  # play the moment that matters
-godot_editor        screenshot_game           # and a screenshot when it's actually worth the tokens
+godot_editor_read   screenshot_game           # and a screenshot when it's actually worth the tokens
 ```
 
 Less copy-paste, more creating.
@@ -65,26 +65,28 @@ Open your Godot project, restart your AI assistant, and start building. If anyth
 
 ## What's in the box
 
-15 tools, ~90 actions, 3 MCP resources. Full API docs in the [Tools Reference](https://github.com/satelliteoflove/godot-mcp/blob/main/docs/tools/README.md).
+21 tools, 86 actions. Full API docs in the [Tools Reference](https://github.com/satelliteoflove/godot-mcp/blob/main/docs/tools/README.md).
 
 | Tool | What it does |
 |------|--------------|
-| `godot_scene` | Open, save, and create scenes |
-| `godot_node` | Create, update, delete, and reparent nodes; attach scripts; connect signals |
-| `godot_editor` | Editor state, selection, run/stop/restart, screenshots, editor error log, 2D viewport control |
-| `godot_project` | Project info and settings |
-| `godot_animation` | Query, play, and edit animations down to individual tracks and keyframes |
-| `godot_tilemap` / `godot_gridmap` | Read and edit TileMapLayer and GridMap cells |
+| `godot_scene` | Open and save scenes (create new scenes by writing the `.tscn` directly, then open) |
+| `godot_node_read` / `godot_node_edit` | Inspect effective properties, the full scene tree (including instanced sub-scenes), and find nodes; update properties and reparent |
+| `godot_editor_read` / `godot_editor_edit` | Editor state, selection, screenshots, editor error log; run/stop/restart and 2D viewport control |
+| `godot_project` | Project info, settings, addon version skew, and stale-settings detection |
+| `godot_animation_read` / `godot_animation_edit` | Query animations down to keyframes; author tracks and keyframes with instant editor preview |
+| `godot_tilemap_read` / `godot_tilemap_edit` | Read and edit TileMapLayer cells (base64-encoded in `.tscn` — the bridge is the only way) |
+| `godot_gridmap_read` / `godot_gridmap_edit` | Read and edit GridMap cells, same story |
 | `godot_resource` | Inspect resources with type-aware output: SpriteFrames, TileSet, Materials, Textures |
-| `godot_scene3d` | 3D transforms, bounding boxes, and visibility for spatial reasoning |
+| `godot_scene3d` | Engine-computed 3D transforms, bounding boxes, and visibility for spatial reasoning |
 | `godot_docs` | Fetch Godot documentation as clean markdown, version-matched to your editor |
 | `godot_input` | Inject input into the running game: actions, joypad, raw keys, mouse-look, text |
 | `godot_profiler` | Metric snapshots and per-frame time series with spike detection |
 | `godot_runtime_state` | Live game state as JSON: one-shot digests, watch windows, signal timelines |
 | `godot_game_time` | Freeze, step, and step-until on the game clock — deterministic observation |
 | `godot_exec` | Run GDScript inside the running game for test scenario setup |
+| `godot_validate_meshes` | Detect silently corrupt procedural mesh data that masquerades as lighting bugs |
 
-A note on shape: this kit deliberately stays at 15 tools rather than 90. Related operations live as actions inside one tool, so your agent's context isn't flooded with tool definitions it won't use.
+A note on shape: tools split along the read/write boundary, so every `godot_*_read` tool (and the other read-only tools) can be safely auto-allowed in your client's permission settings while writes stay gated. Related operations still live as actions inside one tool, so your agent's context isn't flooded with definitions it won't use. Anything an agent can do by editing project files directly — creating scenes and nodes, attaching scripts, connecting signals — is deliberately *not* duplicated as a tool; the bridge covers what files can't: editor state, verification, binary-encoded cell data, and the running game. A `--read-only` flag serves the look-but-don't-touch use case.
 
 ## Things to ask for
 
@@ -121,11 +123,11 @@ One caveat: a Godot editor serves a single godot-mcp client at a time. Extra cli
 ## Documentation
 
 - [Installation Guide](https://github.com/satelliteoflove/godot-mcp/blob/main/INSTALL.md) — MCP client configs for Claude Desktop, Claude Code, VSCode/Copilot, and more
+- [Migrating to v4](https://github.com/satelliteoflove/godot-mcp/blob/main/docs/migrating-to-v4.md) — renamed tools, removed actions, allowlist updates
 - [Troubleshooting](https://github.com/satelliteoflove/godot-mcp/blob/main/docs/troubleshooting.md) — connection checklist, CLI smoke test, common fixes
 - [Claude Code Setup Guide](https://github.com/satelliteoflove/godot-mcp/blob/main/docs/claude-code-setup.md) — CLAUDE.md template for Godot projects
 - [Runtime State Guide](https://github.com/satelliteoflove/godot-mcp/blob/main/docs/runtime-state-guide.md) — expose game state to agents via `mcp_watch` and `_mcp_state()`
-- [Tools Reference](https://github.com/satelliteoflove/godot-mcp/blob/main/docs/tools/README.md) — all 15 tools with full API docs
-- [Resources Reference](https://github.com/satelliteoflove/godot-mcp/blob/main/docs/resources.md) — MCP resources for reading project data
+- [Tools Reference](https://github.com/satelliteoflove/godot-mcp/blob/main/docs/tools/README.md) — all 21 tools with full API docs
 - [Architecture Guide](https://github.com/satelliteoflove/godot-mcp/blob/main/docs/architecture.md) — how the server, addon, and game bridge fit together
 - [Contributing](https://github.com/satelliteoflove/godot-mcp/blob/main/CONTRIBUTING.md) — dev setup, adding tools, release process
 - [Changelog](https://github.com/satelliteoflove/godot-mcp/blob/main/server/CHANGELOG.md) — release history
@@ -141,10 +143,16 @@ One caveat: a Godot editor serves a single godot-mcp client at a time. Extra cli
 ```bash
 cd server
 npm install && npm run build
-npm test
+npm test                # unit + schema-snapshot tests
+npm run test:protocol   # wire-level smoke of the built server
 npm run generate-docs
 ```
 
+There is also an agentic eval harness (`npm run eval`) that runs realistic
+tasks through headless Claude Code against a real project — see
+[server/evals/README.md](https://github.com/satelliteoflove/godot-mcp/blob/main/server/evals/README.md). It never starts Godot; you
+bring the open editor.
+
 Contributions welcome — this project favors tools that solve real, time-wasting problems. Read [CONTRIBUTING.md](https://github.com/satelliteoflove/godot-mcp/blob/main/CONTRIBUTING.md) before building something big, or open an issue and we'll figure out the right shape together.
 
 ## License

package/addon/command_router.gd

@@ -10,7 +10,6 @@ func setup(plugin: EditorPlugin) -> void:
 	_register_handler(MCPSystemCommands.new(), plugin)
 	_register_handler(MCPSceneCommands.new(), plugin)
 	_register_handler(MCPNodeCommands.new(), plugin)
-	_register_handler(MCPScriptCommands.new(), plugin)
 	_register_handler(MCPSelectionCommands.new(), plugin)
 	_register_handler(MCPProjectCommands.new(), plugin)
 	_register_handler(MCPDebugCommands.new(), plugin)

package/addon/commands/debug_commands.gd

@@ -2,21 +2,15 @@
 extends MCPBaseCommand
 class_name MCPDebugCommands
 
-const DEBUG_OUTPUT_TIMEOUT := 5.0
 # Keep in sync with LAUNCH_FROZEN_ENV in mcp_game_bridge.gd.
 const LAUNCH_FROZEN_ENV := "GODOT_MCP_LAUNCH_FROZEN"
 
-var _debug_output_result: PackedStringArray = []
-var _debug_output_pending: bool = false
-
 
 func get_commands() -> Dictionary:
 	return {
 		"run_project": run_project,
 		"stop_project": stop_project,
-		"get_debug_output": get_debug_output,
 		"get_log_messages": get_log_messages,
-		"get_errors": get_errors,
 		"get_stack_trace": get_stack_trace,
 	}
 
@@ -25,8 +19,6 @@ func run_project(params: Dictionary) -> Dictionary:
 	var scene_path: String = params.get("scene_path", "")
 	var frozen: bool = params.get("frozen", false)
 
-	MCPLogger.clear()
-
 	# Launch-frozen: the spawned game inherits the editor's environment, so
 	# setting this before play makes the bridge freeze the tree in _ready —
 	# before the first process frame. Deterministic, unlike sending a freeze
@@ -56,64 +48,6 @@ func stop_project(_params: Dictionary) -> Dictionary:
 	return _success({})
 
 
-func get_debug_output(params: Dictionary) -> Dictionary:
-	var clear: bool = params.get("clear", false)
-	var source: String = params.get("source", "")
-
-	if source == "editor":
-		var output := "\n".join(MCPLogger.get_output())
-		if clear:
-			MCPLogger.clear()
-		return _success({"output": output, "source": "editor"})
-
-	if source == "game":
-		if not EditorInterface.is_playing_scene():
-			return _error("NOT_RUNNING", "No game is currently running. Use source: 'editor' for editor output.")
-		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. Use source: 'editor' for editor output.")
-		return await _fetch_game_debug_output(debugger_plugin, clear)
-
-	if not EditorInterface.is_playing_scene():
-		var output := "\n".join(MCPLogger.get_output())
-		if clear:
-			MCPLogger.clear()
-		return _success({"output": output, "source": "editor"})
-
-	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, "source": "editor"})
-
-	return await _fetch_game_debug_output(debugger_plugin, clear)
-
-
-func _fetch_game_debug_output(debugger_plugin: MCPDebuggerPlugin, clear: bool) -> Dictionary:
-	_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()), "source": "editor"})
-
-	return _success({"output": "\n".join(_debug_output_result), "source": "game"})
-
-
-func _on_debug_output_received(output: PackedStringArray) -> void:
-	_debug_output_pending = false
-	_debug_output_result = output
-
-
 func get_log_messages(params: Dictionary) -> Dictionary:
 	var clear: bool = params.get("clear", false)
 	var limit: int = int(params.get("limit", 50))
@@ -137,10 +71,6 @@ func get_log_messages(params: Dictionary) -> Dictionary:
 	return _success(result)
 
 
-func get_errors(params: Dictionary) -> Dictionary:
-	return get_log_messages(params)
-
-
 func get_stack_trace(_params: Dictionary) -> Dictionary:
 	var frames := MCPLogger.get_last_stack_trace()
 	var errors := MCPLogger.get_errors()

package/addon/commands/exec_commands.gd

@@ -111,7 +111,7 @@ func _send_and_wait(msg_type: String, args: Array, timeout: float, call_id: int)
 			debugger_plugin.clear_response(msg_type)
 			var hint := ""
 			if debugger_plugin.is_session_breaked():
-				hint = " (the game is paused in the editor debugger and did not resume; press Continue in the editor or run godot_editor stop)"
+				hint = " (the game is paused in the editor debugger and did not resume; press Continue in the editor or run godot_editor_edit stop)"
 			_last_error = _error("TIMEOUT", "Timed out waiting for %s response%s" % [msg_type, hint])
 			return null
 	return null  # unreachable; satisfies the parser

package/addon/commands/input_commands.gd

@@ -104,7 +104,7 @@ func _get_editor_input_map() -> Dictionary:
 	# This map is read from the editor's in-memory InputMap, which is loaded at
 	# startup and goes stale if project.godot's [input] section is edited on disk
 	# (#245). Flag that so the caller knows the map may be incomplete and can
-	# recover with `godot_editor restart`. The game-running path above reads fresh
+	# recover with `godot_editor_edit restart`. The game-running path above reads fresh
 	# from the bridge, so it never carries this.
 	var result := {"actions": actions, "source": "editor"}
 	var staleness := MCPUtils.detect_project_staleness()

package/addon/commands/node_commands.gd

@@ -12,11 +12,8 @@ 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,
-		"connect_signal": connect_signal
+		"reparent_node": reparent_node
 	}
 
 
@@ -120,79 +117,6 @@ func _find_recursive(node: Node, scene_root: Node, name_pattern: String, type_fi
 		_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)
-	var scene_root := EditorInterface.get_edited_scene_root()
-	_set_owner_recursive(node, scene_root)
-
-	# Re-apply spatial transforms after add_child: the editor viewport may
-	# snap newly added Node3D nodes to the current 3D cursor position,
-	# overriding properties set before add_child.
-	if node is Node3D:
-		var n3d := node as Node3D
-		if "position" in properties:
-			n3d.position = MCPUtils.deserialize_value(properties["position"])
-		if "rotation" in properties:
-			n3d.rotation = MCPUtils.deserialize_value(properties["rotation"])
-		if "scale" in properties:
-			n3d.scale = MCPUtils.deserialize_value(properties["scale"])
-
-	return _success({"node_path": str(scene_root.get_path_to(node))})
-
-
-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", {})
@@ -214,29 +138,6 @@ func update_node(params: Dictionary) -> Dictionary:
 	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():
@@ -270,45 +171,3 @@ func reparent_node(params: Dictionary) -> Dictionary:
 	return _success({"new_path": str(root.get_path_to(node))})
 
 
-func connect_signal(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 signal_name: String = params.get("signal_name", "")
-	var target_path: String = params.get("target_path", "")
-	var method_name: String = params.get("method_name", "")
-
-	if node_path.is_empty():
-		return _error("INVALID_PARAMS", "node_path is required")
-	if signal_name.is_empty():
-		return _error("INVALID_PARAMS", "signal_name is required")
-	if target_path.is_empty():
-		return _error("INVALID_PARAMS", "target_path is required")
-	if method_name.is_empty():
-		return _error("INVALID_PARAMS", "method_name is required")
-
-	var source_node := _get_node(node_path)
-	if not source_node:
-		return _error("NODE_NOT_FOUND", "Source node not found: %s" % node_path)
-
-	var target_node := _get_node(target_path)
-	if not target_node:
-		return _error("NODE_NOT_FOUND", "Target node not found: %s" % target_path)
-
-	if not source_node.has_signal(signal_name):
-		return _error("SIGNAL_NOT_FOUND", "Signal '%s' not found on node %s" % [signal_name, node_path])
-
-	if source_node.is_connected(signal_name, Callable(target_node, method_name)):
-		return _error("ALREADY_CONNECTED", "Signal '%s' is already connected to %s.%s()" % [signal_name, target_path, method_name])
-
-	var err := source_node.connect(signal_name, Callable(target_node, method_name), CONNECT_PERSIST)
-	if err != OK:
-		return _error("CONNECT_FAILED", "Failed to connect signal: %s" % error_string(err))
-
-	EditorInterface.mark_scene_as_unsaved()
-
-	return _success({})
-
-

package/addon/commands/project_commands.gd

@@ -13,7 +13,7 @@ func get_commands() -> Dictionary:
 
 # Detect whether project.godot was edited on disk after the editor loaded it,
 # leaving the editor's in-memory ProjectSettings / InputMap stale (#245). Always
-# returns the full report (stale or not); recovery is `godot_editor restart`.
+# returns the full report (stale or not); recovery is `godot_editor_edit restart`.
 func get_project_staleness(_params: Dictionary) -> Dictionary:
 	return _success(MCPUtils.detect_project_staleness())
 

package/addon/commands/scene_commands.gd

@@ -5,39 +5,25 @@ class_name MCPSceneCommands
 
 func get_commands() -> Dictionary:
 	return {
-		"get_current_scene": get_current_scene,
 		"get_scene_tree": get_scene_tree,
 		"open_scene": open_scene,
-		"save_scene": save_scene,
-		"create_scene": create_scene
+		"save_scene": save_scene
 	}
 
 
-func get_current_scene(_params: Dictionary) -> Dictionary:
-	var root := EditorInterface.get_edited_scene_root()
-	if not root:
-		return _success({
-			"path": null,
-			"root_name": null,
-			"root_type": null
-		})
-
-	return _success({
-		"path": root.scene_file_path,
-		"root_name": root.name,
-		"root_type": root.get_class()
-	})
-
-
-func get_scene_tree(_params: Dictionary) -> Dictionary:
+func get_scene_tree(params: Dictionary) -> Dictionary:
 	var root := EditorInterface.get_edited_scene_root()
 	if not root:
 		return _error("NO_SCENE", "No scene is currently open")
 
-	return _success({"tree": _build_tree(root)})
+	# 0 = unlimited for both caps (the default when the param is omitted), so the
+	# full tree is unchanged unless a caller opts into trimming it.
+	var max_depth: int = int(params.get("max_depth", 0))
+	var max_children: int = int(params.get("max_children", 0))
+	return _success({"tree": _build_tree(root, 1, max_depth, max_children)})
 
 
-func _build_tree(node: Node) -> Dictionary:
+func _build_tree(node: Node, depth: int, max_depth: int, max_children: int) -> Dictionary:
 	var result := {
 		"name": node.name,
 		"type": node.get_class(),
@@ -50,12 +36,29 @@ func _build_tree(node: Node) -> Dictionary:
 		var pos: Vector3 = node.position
 		result["position"] = {"x": pos.x, "y": pos.y, "z": pos.z}
 
+	var child_nodes := node.get_children()
+	var child_count := child_nodes.size()
+	if child_count == 0:
+		return result
+
+	# Depth cap: at the limit, stop recursing and just report how many direct
+	# children were cut off.
+	if max_depth > 0 and depth >= max_depth:
+		result["truncated_children"] = child_count
+		return result
+
+	# Breadth cap: list the first max_children and report the remainder.
+	var limit := child_count
+	if max_children > 0 and child_count > max_children:
+		limit = max_children
+
 	var children: Array[Dictionary] = []
-	for child in node.get_children():
-		children.append(_build_tree(child))
+	for i in range(limit):
+		children.append(_build_tree(child_nodes[i], depth + 1, max_depth, max_children))
 
-	if not children.is_empty():
-		result["children"] = children
+	result["children"] = children
+	if limit < child_count:
+		result["truncated_children"] = child_count - limit
 
 	return result
 
@@ -95,39 +98,3 @@ func save_scene(params: Dictionary) -> Dictionary:
 
 	return _success({"path": path})
 
-
-func create_scene(params: Dictionary) -> Dictionary:
-	var root_type: String = params.get("root_type", "")
-	var root_name: String = params.get("root_name", root_type)
-	var scene_path: String = params.get("scene_path", "")
-
-	if root_type.is_empty():
-		return _error("INVALID_PARAMS", "root_type is required")
-	if scene_path.is_empty():
-		return _error("INVALID_PARAMS", "scene_path is required")
-
-	if not ClassDB.class_exists(root_type):
-		return _error("INVALID_TYPE", "Unknown node type: %s" % root_type)
-
-	var root: Node = ClassDB.instantiate(root_type)
-	if not root:
-		return _error("CREATE_FAILED", "Failed to create node of type: %s" % root_type)
-
-	root.name = root_name
-
-	var packed_scene := PackedScene.new()
-	var err := packed_scene.pack(root)
-	root.free()
-
-	if err != OK:
-		return _error("PACK_FAILED", "Failed to pack scene: %s" % error_string(err))
-
-	err = ResourceSaver.save(packed_scene, scene_path)
-	if err != OK:
-		return _error("SAVE_FAILED", "Failed to save scene: %s" % error_string(err))
-
-	EditorInterface.open_scene_from_path(scene_path)
-
-	var uid := ResourceUID.id_to_text(ResourceLoader.get_resource_uid(scene_path))
-	return _success({"path": scene_path, "uid": uid})
-

package/addon/commands/selection_commands.gd

@@ -90,14 +90,27 @@ func set_2d_viewport(params: Dictionary) -> Dictionary:
 	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)
+	var size := viewport.size
+
+	# Read the current view first so any omitted parameter preserves it instead of
+	# snapping to a default (a zoom-only call keeps the current center, not 0,0).
+	# This inverts the same transform math applied below — see
+	# _get_editor_2d_viewport_info().
+	var current := viewport.global_canvas_transform
+	var current_zoom: float = current.x.x
+	var current_offset: Vector2 = -current.origin / current_zoom
+	var current_center := Vector2(
+		current_offset.x + size.x / current_zoom / 2,
+		current_offset.y + size.y / current_zoom / 2
+	)
+
+	var center_x: float = params.get("center_x", current_center.x)
+	var center_y: float = params.get("center_y", current_center.y)
+	var zoom: float = params.get("zoom", current_zoom)
 
 	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
 

package/addon/core/base_command.gd

@@ -34,27 +34,3 @@ func _require_scene_open() -> Dictionary:
 	if not root:
 		return _error("NO_SCENE", "No scene is currently open")
 	return {}
-
-
-func _require_typed_node(path: String, type: String, type_error_code: String = "WRONG_TYPE") -> Variant:
-	var node := _get_node(path)
-	if not node:
-		return _error("NODE_NOT_FOUND", "Node not found: %s" % path)
-	if not node.is_class(type):
-		return _error(type_error_code, "Expected %s, got %s" % [type, node.get_class()])
-	return node
-
-
-func _find_nodes_of_type(root: Node, type: String) -> Array[Dictionary]:
-	var result: Array[Dictionary] = []
-	var scene_root := EditorInterface.get_edited_scene_root()
-	if scene_root:
-		_find_nodes_recursive(root, type, result, scene_root)
-	return result
-
-
-func _find_nodes_recursive(node: Node, type: String, result: Array[Dictionary], scene_root: Node) -> void:
-	if node.is_class(type):
-		result.append({"path": str(scene_root.get_path_to(node)), "name": node.name})
-	for child in node.get_children():
-		_find_nodes_recursive(child, type, result, scene_root)

package/addon/core/mcp_debugger_plugin.gd

@@ -3,14 +3,12 @@ extends EditorDebuggerPlugin
 class_name MCPDebuggerPlugin
 
 signal screenshot_received(success: bool, image_base64: String, width: int, height: int, error: String)
-signal debug_output_received(output: PackedStringArray)
 signal performance_metrics_received(metrics: Dictionary)
 signal find_nodes_received(matches: Array, count: int, error: String)
 signal input_map_received(actions: Array, error: String)
 signal input_sequence_completed(result: Dictionary)
 signal sequence_capture_received(requested_ms: int, actual_ms: int, ok: bool, image_base64: String, width: int, height: int, error: String)
 signal type_text_completed(result: Dictionary)
-signal game_response(message_type: String, data: Variant)
 signal bridge_ready()
 
 var _active_session_id: int = -1
@@ -23,7 +21,6 @@ var _pending_screenshot: bool = false
 # (element 6 of screenshot_result; empty for bridges that predate it). Held
 # here instead of widening the screenshot_received signal signature.
 var last_screenshot_warnings: Array = []
-var _pending_debug_output: bool = false
 var _pending_performance_metrics: bool = false
 var _pending_find_nodes: bool = false
 var _pending_input_map: bool = false
@@ -42,9 +39,6 @@ func _capture(message: String, data: Array, session_id: int) -> bool:
 		"godot_mcp:screenshot_result":
 			_handle_screenshot_result(data)
 			return true
-		"godot_mcp:debug_output_result":
-			_handle_debug_output_result(data)
-			return true
 		"godot_mcp:performance_metrics_result":
 			_handle_performance_metrics_result(data)
 			return true
@@ -93,9 +87,6 @@ func _session_stopped() -> void:
 	if _pending_screenshot:
 		_pending_screenshot = false
 		screenshot_received.emit(false, "", 0, 0, "Game session ended")
-	if _pending_debug_output:
-		_pending_debug_output = false
-		debug_output_received.emit(PackedStringArray())
 	if _pending_performance_metrics:
 		_pending_performance_metrics = false
 		performance_metrics_received.emit({})
@@ -159,25 +150,6 @@ func _handle_screenshot_result(data: Array) -> void:
 	screenshot_received.emit(success, image_base64, width, height, error)
 
 
-func request_debug_output(clear: bool = false) -> void:
-	if _active_session_id < 0:
-		debug_output_received.emit(PackedStringArray())
-		return
-	_pending_debug_output = true
-	var session := get_session(_active_session_id)
-	if session:
-		session.send_message("godot_mcp:get_debug_output", [clear])
-	else:
-		_pending_debug_output = false
-		debug_output_received.emit(PackedStringArray())
-
-
-func _handle_debug_output_result(data: Array) -> void:
-	_pending_debug_output = false
-	var output: PackedStringArray = data[0] if data.size() > 0 else PackedStringArray()
-	debug_output_received.emit(output)
-
-
 func request_performance_metrics() -> void:
 	if _active_session_id < 0:
 		performance_metrics_received.emit({})
@@ -322,7 +294,6 @@ func _handle_game_response(data: Array) -> void:
 	var response_data: Variant = data[1]
 	_pending_requests.erase(msg_type)
 	_responses[msg_type] = response_data
-	game_response.emit(msg_type, response_data)
 
 
 func toggle_frame_profiler(enable: bool) -> void: