@baixfeng/godot-mcp-cli 1.0.11

package/addons/godot_mcp/commands/debugger_commands.gd

@@ -0,0 +1,221 @@
+@tool
+class_name MCPDebuggerCommands
+extends MCPBaseCommandProcessor
+
+# Reference to the debugger bridge provided by the plugin
+var _debugger_bridge = null
+
+func _ready():
+    _debugger_bridge = _get_debugger_bridge()
+
+    if _debugger_bridge:
+        # Connect signals so the bridge can forward debugger events to MCP
+        _debugger_bridge.breakpoint_hit.connect(_on_breakpoint_hit)
+        _debugger_bridge.execution_paused.connect(_on_execution_paused)
+        _debugger_bridge.execution_resumed.connect(_on_execution_resumed)
+        _debugger_bridge.stack_frame_changed.connect(_on_stack_frame_changed)
+        _debugger_bridge.breakpoint_set.connect(_on_breakpoint_set)
+        _debugger_bridge.breakpoint_removed.connect(_on_breakpoint_removed)
+    else:
+        print('[MCPDebuggerCommands] Warning: Could not get debugger bridge reference')
+
+func _get_debugger_bridge():
+    if Engine.has_meta('MCPDebuggerBridge'):
+        return Engine.get_meta('MCPDebuggerBridge')
+
+    var plugin = Engine.get_meta('GodotMCPPlugin')
+    if plugin and plugin.has_method('get_debugger_bridge'):
+        return plugin.get_debugger_bridge()
+
+    return null
+
+func _ensure_bridge(client_id: int, command_id: String) -> bool:
+    if _debugger_bridge:
+        return true
+
+    _send_error(client_id, 'Debugger bridge not available', command_id)
+    return false
+
+func _normalize_script_path(script_path: String) -> String:
+    if script_path.is_empty():
+        return script_path
+
+    if script_path.begins_with('res://'):
+        return script_path
+
+    if script_path.begins_with('/'):
+        return 'res://' + script_path.substr(1)
+
+    return 'res://' + script_path
+
+func _forward_bridge_result(client_id: int, command_id: String, result: Variant, failure_message: String) -> void:
+    if result is Dictionary and not result.get('success', true):
+        _send_error(client_id, result.get('message', failure_message), command_id)
+        return
+
+    _send_success(client_id, result, command_id)
+
+func _call_breakpoint_operation(client_id: int, params: Dictionary, command_id: String, method_name: String, failure_message: String) -> void:
+    if not _ensure_bridge(client_id, command_id):
+        return
+
+    var script_path: String = params.get('script_path', '')
+    var line: int = params.get('line', -1)
+
+    if script_path.is_empty():
+        _send_error(client_id, 'script_path parameter is required', command_id)
+        return
+
+    if line < 0:
+        _send_error(client_id, 'line parameter must be >= 0', command_id)
+        return
+
+    script_path = _normalize_script_path(script_path)
+
+    var result = _debugger_bridge.call(method_name, script_path, line)
+    _forward_bridge_result(client_id, command_id, result, failure_message)
+
+func _call_bridge_no_args(client_id: int, command_id: String, method_name: String, failure_message: String) -> void:
+    if not _ensure_bridge(client_id, command_id):
+        return
+
+    var result = _debugger_bridge.call(method_name)
+    _forward_bridge_result(client_id, command_id, result, failure_message)
+
+func process_command(client_id: int, command_type: String, params: Dictionary, command_id: String) -> bool:
+    match command_type:
+        'debugger_set_breakpoint':
+            _call_breakpoint_operation(client_id, params, command_id, 'set_breakpoint', 'Failed to set breakpoint')
+            return true
+        'debugger_remove_breakpoint':
+            _call_breakpoint_operation(client_id, params, command_id, 'remove_breakpoint', 'Failed to remove breakpoint')
+            return true
+        'debugger_get_breakpoints':
+            _get_breakpoints(client_id, params, command_id)
+            return true
+        'debugger_clear_all_breakpoints':
+            _call_bridge_no_args(client_id, command_id, 'clear_all_breakpoints', 'Failed to clear all breakpoints')
+            return true
+        'debugger_pause_execution':
+            _call_bridge_no_args(client_id, command_id, 'pause_execution', 'Failed to pause execution')
+            return true
+        'debugger_resume_execution':
+            _call_bridge_no_args(client_id, command_id, 'resume_execution', 'Failed to resume execution')
+            return true
+        'debugger_step_over':
+            _call_bridge_no_args(client_id, command_id, 'step_over', 'Failed to step over')
+            return true
+        'debugger_step_into':
+            _call_bridge_no_args(client_id, command_id, 'step_into', 'Failed to step into')
+            return true
+        'debugger_get_call_stack':
+            await _get_call_stack(client_id, params, command_id)
+            return true
+        'debugger_get_current_state':
+            _get_current_state(client_id, params, command_id)
+            return true
+        'debugger_enable_events':
+            _enable_debugger_events(client_id, params, command_id)
+            return true
+        'debugger_disable_events':
+            _disable_debugger_events(client_id, params, command_id)
+            return true
+    return false
+
+func _get_breakpoints(client_id: int, params: Dictionary, command_id: String) -> void:
+    if not _ensure_bridge(client_id, command_id):
+        return
+
+    var result = _debugger_bridge.get_breakpoints()
+    _send_success(client_id, result, command_id)
+
+func _parse_session_identifier(raw_value) -> Variant:
+    var session_id = raw_value
+    var value_type := typeof(raw_value)
+    match value_type:
+        TYPE_INT:
+            return raw_value
+        TYPE_FLOAT:
+            return int(raw_value)
+        TYPE_STRING:
+            var session_str: String = raw_value
+            if session_str.is_valid_int():
+                return int(session_str)
+            return session_str.strip_edges()
+        _:
+            return raw_value
+    return session_id
+
+func _get_call_stack(client_id: int, params: Dictionary, command_id: String):
+    if not _ensure_bridge(client_id, command_id):
+        return
+
+    var session_id = null
+    if params.has('session_id'):
+        session_id = _parse_session_identifier(params['session_id'])
+
+    var result = await _debugger_bridge.get_call_stack(session_id)
+    if typeof(result) == TYPE_DICTIONARY and result.has("error"):
+        var message := String(result.get("message", result.get("error", "unknown_call_stack_error")))
+        _send_error(client_id, "Failed to capture call stack: %s" % message, command_id)
+        return
+
+    _send_success(client_id, result, command_id)
+
+func _get_current_state(client_id: int, params: Dictionary, command_id: String) -> void:
+    if not _ensure_bridge(client_id, command_id):
+        return
+
+    var result = _debugger_bridge.get_current_state()
+    _send_success(client_id, result, command_id)
+
+func _enable_debugger_events(client_id: int, params: Dictionary, command_id: String) -> void:
+    if not _ensure_bridge(client_id, command_id):
+        return
+
+    _debugger_bridge.set_client_id(client_id)
+
+    if not _debugger_bridge._websocket_server:
+        _debugger_bridge.set_websocket_server(_websocket_server)
+
+    _send_success(client_id, {
+        'message': 'Debugger events enabled for this client',
+        'client_id': client_id,
+    }, command_id)
+
+func _disable_debugger_events(client_id: int, params: Dictionary, command_id: String) -> void:
+    if not _ensure_bridge(client_id, command_id):
+        return
+
+    if _debugger_bridge._current_client_id == client_id:
+        _debugger_bridge.set_client_id(-1)
+
+    _send_success(client_id, {
+        'message': 'Debugger events disabled for this client',
+        'client_id': client_id,
+    }, command_id)
+
+# Signal handlers to provide editor-side visibility into debugger activity
+func _on_breakpoint_hit(session_id: int, script_path: String, line: int, stack_info: Dictionary) -> void:
+    print('Breakpoint hit in session %s at %s:%d' % [session_id, script_path, line])
+
+func _on_execution_paused(session_id: int, reason: String) -> void:
+    print('Execution paused in session %s: %s' % [session_id, reason])
+
+func _on_execution_resumed(session_id: int) -> void:
+    print('Execution resumed in session %s' % session_id)
+
+func _on_stack_frame_changed(session_id: int, frame_info: Dictionary) -> void:
+    print('Stack frame changed in session %s' % session_id)
+
+func _on_breakpoint_set(session_id: int, script_path: String, line: int, success: bool) -> void:
+    if success:
+        print('Breakpoint set successfully at %s:%d' % [script_path, line])
+    else:
+        print('Failed to set breakpoint at %s:%d' % [script_path, line])
+
+func _on_breakpoint_removed(session_id: int, script_path: String, line: int, success: bool) -> void:
+    if success:
+        print('Breakpoint removed successfully at %s:%d' % [script_path, line])
+    else:
+        print('Failed to remove breakpoint at %s:%d' % [script_path, line])

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

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

package/addons/godot_mcp/commands/editor_commands.gd

@@ -0,0 +1,237 @@
+@tool
+class_name MCPEditorCommands
+extends MCPBaseCommandProcessor
+
+func process_command(client_id: int, command_type: String, params: Dictionary, command_id: String) -> bool:
+	match command_type:
+		"get_editor_state":
+			_get_editor_state(client_id, params, command_id)
+			return true
+		"get_selected_node":
+			_get_selected_node(client_id, params, command_id)
+			return true
+		"create_resource":
+			_create_resource(client_id, params, command_id)
+			return true
+		"reload_project":
+			_reload_project(client_id, params, command_id)
+			return true
+		"reload_scene":
+			_reload_scene(client_id, params, command_id)
+			return true
+		"rescan_filesystem":
+			_rescan_filesystem(client_id, params, command_id)
+			return true
+	return false  # Command not handled
+
+func _get_editor_state(client_id: int, params: Dictionary, command_id: String) -> void:
+	# 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 state = {
+		"current_scene": "",
+		"current_script": "",
+		"selected_nodes": [],
+		"is_playing": editor_interface.is_playing_scene()
+	}
+	
+	# Get current scene
+	var edited_scene_root = editor_interface.get_edited_scene_root()
+	if edited_scene_root:
+		state["current_scene"] = edited_scene_root.scene_file_path
+	
+	# Get current script if any is being edited
+	var script_editor = editor_interface.get_script_editor()
+	var current_script = script_editor.get_current_script()
+	if current_script:
+		state["current_script"] = current_script.resource_path
+	
+	# Get selected nodes
+	var selection = editor_interface.get_selection()
+	var selected_nodes = selection.get_selected_nodes()
+	
+	for node in selected_nodes:
+		state["selected_nodes"].append({
+			"name": node.name,
+			"path": str(node.get_path())
+		})
+	
+	_send_success(client_id, state, command_id)
+
+func _get_selected_node(client_id: int, params: Dictionary, command_id: String) -> void:
+	# 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 selection = editor_interface.get_selection()
+	var selected_nodes = selection.get_selected_nodes()
+	
+	if selected_nodes.size() == 0:
+		return _send_success(client_id, {
+			"selected": false,
+			"message": "No node is currently selected"
+		}, command_id)
+	
+	var node = selected_nodes[0]  # Get the first selected node
+	
+	# Get node info
+	var node_data = {
+		"selected": true,
+		"name": node.name,
+		"type": node.get_class(),
+		"path": str(node.get_path())
+	}
+	
+	# Get script info if available
+	var script = node.get_script()
+	if script:
+		node_data["script_path"] = script.resource_path
+	
+	# Get important 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
+			# Only include some common properties to avoid overwhelming data
+			if name in ["position", "rotation", "scale", "visible", "modulate", "z_index"]:
+				properties[name] = node.get(name)
+	
+	node_data["properties"] = properties
+	
+	_send_success(client_id, node_data, command_id)
+
+func _create_resource(client_id: int, params: Dictionary, command_id: String) -> void:
+	var resource_type = params.get("resource_type", "")
+	var resource_path = params.get("resource_path", "")
+	var properties = params.get("properties", {})
+	
+	# Validation
+	if resource_type.is_empty():
+		return _send_error(client_id, "Resource type cannot be empty", command_id)
+	
+	if resource_path.is_empty():
+		return _send_error(client_id, "Resource path cannot be empty", command_id)
+	
+	# Make sure we have an absolute path
+	if not resource_path.begins_with("res://"):
+		resource_path = "res://" + resource_path
+	
+	# Get editor interface
+	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()
+	
+	# Create the resource
+	var resource
+	
+	if ClassDB.class_exists(resource_type):
+		if ClassDB.is_parent_class(resource_type, "Resource"):
+			resource = ClassDB.instantiate(resource_type)
+			if not resource:
+				return _send_error(client_id, "Failed to instantiate resource: %s" % resource_type, command_id)
+		else:
+			return _send_error(client_id, "Type is not a Resource: %s" % resource_type, command_id)
+	else:
+		return _send_error(client_id, "Invalid resource type: %s" % resource_type, command_id)
+	
+	# Set properties
+	for key in properties:
+		resource.set(key, properties[key])
+	
+	# Create directory if needed
+	var dir = resource_path.get_base_dir()
+	if not DirAccess.dir_exists_absolute(dir):
+		var err = DirAccess.make_dir_recursive_absolute(dir)
+		if err != OK:
+			return _send_error(client_id, "Failed to create directory: %s (Error code: %d)" % [dir, err], command_id)
+	
+	# Save the resource
+	var result = ResourceSaver.save(resource, resource_path)
+	if result != OK:
+		return _send_error(client_id, "Failed to save resource: %d" % result, command_id)
+	
+	# Refresh the filesystem
+	editor_interface.get_resource_filesystem().scan()
+	
+	_send_success(client_id, {
+		"resource_path": resource_path,
+		"resource_type": resource_type
+	}, command_id)
+
+func _reload_project(client_id: int, params: Dictionary, command_id: String) -> void:
+	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 save_before_restart: bool = params.get("save", true)
+	
+	# Send success response before restarting (since restart will disconnect)
+	_send_success(client_id, {
+		"status": "restarting",
+		"save": save_before_restart,
+		"message": "Godot editor is restarting..."
+	}, command_id)
+	
+	# Use call_deferred to allow the response to be sent before restart
+	editor_interface.call_deferred("restart_editor", save_before_restart)
+
+func _reload_scene(client_id: int, params: Dictionary, command_id: String) -> void:
+	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 scene_path: String = params.get("scene_path", "")
+	
+	# If no scene path provided, reload the current scene
+	if scene_path.is_empty():
+		var edited_scene_root = editor_interface.get_edited_scene_root()
+		if not edited_scene_root:
+			return _send_error(client_id, "No scene is currently open in the editor", command_id)
+		
+		scene_path = edited_scene_root.scene_file_path
+		if scene_path.is_empty():
+			return _send_error(client_id, "Current scene has not been saved yet", command_id)
+	
+	# Validate scene path
+	if not scene_path.begins_with("res://"):
+		scene_path = "res://" + scene_path
+	
+	if not ResourceLoader.exists(scene_path):
+		return _send_error(client_id, "Scene does not exist: %s" % scene_path, command_id)
+	
+	# Reload the scene from disk
+	editor_interface.reload_scene_from_path(scene_path)
+	
+	_send_success(client_id, {
+		"status": "reloaded",
+		"scene_path": scene_path,
+		"message": "Scene reloaded from disk"
+	}, command_id)
+
+func _rescan_filesystem(client_id: int, params: Dictionary, command_id: String) -> void:
+	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 filesystem = editor_interface.get_resource_filesystem()
+	
+	# Trigger filesystem scan
+	filesystem.scan()
+	
+	_send_success(client_id, {
+		"status": "scanning",
+		"message": "Filesystem rescan initiated"
+	}, command_id)

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

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