@satelliteoflove/godot-mcp 2.11.0 → 2.12.0

package/README.md

@@ -1,33 +1,18 @@
 # godot-mcp
 
-An MCP server that gives Claude direct visibility into your Godot editor and running game. Instead of copy-pasting debug output or describing what you're seeing, Claude can observe it directly.
+MCP server that connects Claude to your Godot editor. Less copy-paste, more creating.
 
-## Core Capabilities
+## Why This Exists
 
-**Observe** - Claude sees what you see
-- Live editor state, selection, and open scenes
-- Screenshots from editor viewports or running game
-- Debug output and performance metrics from runtime
-- Camera position and viewport in 2D and 3D
+Using AI assistants for game dev means a lot of back-and-forth: copying error messages, describing what's on screen, pasting debug output, manually applying suggested changes. It works, but it's tedious.
 
-**Inspect** - Deep access to your project
-- Scene tree traversal with node properties
-- 3D spatial data: transforms, bounding boxes, visibility
-- Resource introspection: SpriteFrames, TileSets, Materials
-- Project settings and input mappings
-
-**Modify** - Direct manipulation when needed
-- Create, update, delete, and reparent nodes
-- Attach and detach scripts
-- Edit TileMapLayers and GridMaps cell-by-cell
-- Control animation playback and edit tracks/keyframes
-- Run and stop the game from the editor
+This MCP gives Claude direct access to your Godot editor. It can see your scene tree, capture screenshots, read errors, and make changes directly. You stay focused on the creative work while the mechanical relay disappears. Faster iterations, less busywork, more time building the game you actually want to make.
 
 ## Quick Start
 
-### 1. Configure Your AI Assistant
+### 1. Configure your AI assistant
 
-**Claude Desktop** - Add to config (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):
+**Claude Desktop** (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):
 
 ```json
 {
@@ -40,7 +25,7 @@ An MCP server that gives Claude direct visibility into your Godot editor and run
 }
 ```
 
-**Claude Code** - Add to `.mcp.json`:
+**Claude Code** (`.mcp.json` in your project):
 
 ```json
 {
@@ -53,44 +38,91 @@ An MCP server that gives Claude direct visibility into your Godot editor and run
 }
 ```
 
-### 2. Install the Godot Addon
+### 2. Install the Godot addon
 
 ```bash
 npx @satelliteoflove/godot-mcp --install-addon /path/to/your/godot/project
 ```
 
-Then enable the addon in Godot: Project Settings > Plugins > Godot MCP.
+Enable in Godot: **Project Settings > Plugins > Godot MCP**
 
-### 3. Start Using
+### 3. Go
 
-Open your Godot project (with addon enabled), restart your AI assistant, and start building.
+Open your Godot project, restart your AI assistant, and start building.
 
-**Version Sync:** The MCP server auto-updates via npx. Version mismatches are detected automatically on connection. If prompted, re-run the install command to update the addon.
+## What Claude Can Do
 
-## Tools
+- **See** your editor, scenes, running game, errors, and performance
+- **Inspect** nodes, resources, animations, tilemaps, 3D spatial data
+- **Modify** scenes, nodes, scripts, animations, tilemaps directly
+- **Test** by running the game and injecting input
+- **Learn** by fetching Godot docs on demand
 
-| Tool | Description |
-|------|-------------|
-| `scene` | Manage scenes: open, save, or create scenes |
-| `node` | Manage scene nodes: get properties, find, create, update, delete, reparent, attach/detach scripts, connect signals |
-| `editor` | Control the Godot editor: get state (includes viewport/camera info), manage selection, run/stop project, get debug output, get_log_messages (errors/warnings with filter/limit), get_stack_trace (backtrace from last error), get performance metrics, capture screenshots, set 2D viewport position/zoom |
-| `project` | Get project information and settings |
-| `animation` | Query, control, and edit animations |
-| `tilemap` | Query and edit TileMapLayer data: list layers, get info, get/set cells, convert coordinates |
-| `gridmap` | Query and edit GridMap data: list gridmaps, get info, get/set cells |
-| `resource` | Manage Godot resources: inspect Resource files by path |
-| `scene3d` | Get spatial information for 3D nodes: global transforms, bounding boxes, visibility |
-| `godot_docs` | Fetch Godot Engine documentation |
-| `input` | Inject input into a running Godot game for testing |
+## Documentation
 
-See [docs/](docs/) for detailed API reference, including the [Claude Code Setup Guide](docs/claude-code-setup.md).
+- [Claude Code Setup Guide](../docs/claude-code-setup.md) - CLAUDE.md templates and workflows
+- [Tools Reference](../docs/tools/README.md) - All 11 tools with full API docs
+- [Resources Reference](../docs/resources.md) - MCP resources for reading project data
+- [Contributing](../CONTRIBUTING.md) - Dev setup, adding tools, release process
+- [Changelog](CHANGELOG.md) - Release history
 
 ## Architecture
 
 ```
-[AI Assistant] <--stdio--> [MCP Server] <--WebSocket--> [Godot Addon]
+[Claude/AI Assistant/MCP Client] <--stdio--> [MCP Server] <--WebSocket:6550--> [Godot MCP Bridge Addon]
+```
+
+### WSL Support
+
+The MCP server has built-in support for Windows Subsystem for Linux (WSL2):
+
+- **Auto-detection**: MCP server automatically detects WSL environment via environment variables and `/proc/version`
+- **Host IP discovery**: Auto-discovers Windows host IP from WSL to connect to Godot running on Windows
+- **Configuration**:
+  - `GODOT_HOST` overrides the Godot addon host (auto-detected in WSL)
+  - `GODOT_PORT` overrides the Godot addon port (default `6550`)
+
+**Security note:** the Godot addon binds to `127.0.0.1` by default.
+
+In the Godot Editor bottom panel (**MCP**), you can configure what the addon listens on:
+- **Bind mode: Localhost** (default) → `127.0.0.1`
+- **Bind mode: WSL** → Windows `vEthernet (WSL)` IPv4 (required for Windows Godot + WSL2 server)
+- **Bind mode: Custom** → bind to a specific IP
+- **Port override** → change the listen port from `6550`
+
+If you enable **Port override**, set `GODOT_PORT` on the server to match.
+
+## CLI smoke test (paste-ready JSON-RPC)
+
+If you run the server manually via CLI (for example: `npx -y @satelliteoflove/godot-mcp`), you can paste these **stdio JSON-RPC frames** to verify it responds and can reach Godot:
+
+1) Write in CLI
+
+```json
+{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"cli-test","version":"0"}}}
+```
+
+2) Response
+
+```json
+{"result":{"protocolVersion":"2024-11-05","capabilities":{"tools":{},"resources":{},"logging":{}},"serverInfo":{"name":"godot-mcp","version":"2.11.0"}},"jsonrpc":"2.0","id":1}
 ```
 
+3) Call a tool
+
+```json
+{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"editor","arguments":{"action":"get_state"}}}
+```
+
+4) Response
+
+```json
+{"result":{"content":[{"type":"text","text":"{\n  \"current_scene\": null,\n  \"godot_version\": \"4.5.1-stable (official)\",\n  \"is_playing\": false,\n  \"main_screen\": \"unknown\",\n  \"open_scenes\": []\n}"}]},"jsonrpc":"2.0","id":2}
+```
+
+Tip: If you enabled **Port override** in the Godot MCP panel, start the server with matching env vars (or export as environment variable):
+`GODOT_HOST=... GODOT_PORT=... npm run start` or `GODOT_HOST=... GODOT_PORT=... npx -y @satelliteoflove/godot-mcp`
+
 ## Development
 
 ```bash

package/addon/core/mcp_constants.gd

@@ -0,0 +1,5 @@
+class_name MCPConstants
+
+const LOCALHOST_BIND_ADDRESS = "127.0.0.1"
+const PORT_MIN = 1
+const PORT_MAX = 65535

package/addon/core/mcp_enums.gd

@@ -0,0 +1,10 @@
+class_name MCPEnums
+
+enum BindMode { LOCALHOST, WSL, CUSTOM }
+
+static func get_mode_name(mode: BindMode) -> String:
+	match mode:
+		BindMode.LOCALHOST: return "Localhost"
+		BindMode.WSL:       return "WSL"
+		BindMode.CUSTOM:    return "Custom"
+		_:                  return "Unknown"

package/addon/plugin.cfg

@@ -3,6 +3,6 @@
 name="Godot MCP"
 description="Model Context Protocol server for AI assistant integration"
 author="godot-mcp"
-version="2.11.0"
+version="2.12.0"
 script="plugin.gd"
 godot_version_min="4.5"

package/addon/plugin.gd

@@ -9,11 +9,19 @@ const MCPDebuggerPlugin := preload("res://addons/godot_mcp/core/mcp_debugger_plu
 const GAME_BRIDGE_AUTOLOAD := "MCPGameBridge"
 const GAME_BRIDGE_PATH := "res://addons/godot_mcp/game_bridge/mcp_game_bridge.gd"
 
+const SETTING_BIND_MODE := "godot_mcp/bind_mode"
+const SETTING_CUSTOM_BIND_IP := "godot_mcp/custom_bind_ip"
+const SETTING_PORT_OVERRIDE_ENABLED := "godot_mcp/port_override_enabled"
+const SETTING_PORT_OVERRIDE := "godot_mcp/port_override"
+
 var _websocket_server: WebSocketServer
 var _command_router: CommandRouter
 var _status_panel: Control
 var _debugger_plugin: MCPDebuggerPlugin
 
+var _current_bind_address := MCPConstants.LOCALHOST_BIND_ADDRESS
+var _current_bind_mode: MCPEnums.BindMode = MCPEnums.BindMode.LOCALHOST
+
 
 func _enter_tree() -> void:
 	_command_router = CommandRouter.new()
@@ -27,14 +35,14 @@ func _enter_tree() -> void:
 
 	_status_panel = StatusPanel.instantiate()
 	add_control_to_bottom_panel(_status_panel, "MCP")
-	_update_status("Waiting for connection...")
 
 	_debugger_plugin = MCPDebuggerPlugin.new()
 	add_debugger_plugin(_debugger_plugin)
 
 	_ensure_game_bridge_autoload()
-
-	_websocket_server.start_server()
+	_ensure_bind_settings()
+	_setup_bind_ui()
+	_apply_bind_settings(true)
 	MCPLog.info("Plugin initialized")
 
 
@@ -57,6 +65,152 @@ func _exit_tree() -> void:
 	MCPLog.info("Plugin disabled")
 
 
+func _ensure_bind_settings() -> void:
+	if not ProjectSettings.has_setting(SETTING_BIND_MODE):
+		ProjectSettings.set_setting(SETTING_BIND_MODE, MCPEnums.BindMode.LOCALHOST)
+	if not ProjectSettings.has_setting(SETTING_CUSTOM_BIND_IP):
+		ProjectSettings.set_setting(SETTING_CUSTOM_BIND_IP, "")
+	if not ProjectSettings.has_setting(SETTING_PORT_OVERRIDE_ENABLED):
+		ProjectSettings.set_setting(SETTING_PORT_OVERRIDE_ENABLED, false)
+	if not ProjectSettings.has_setting(SETTING_PORT_OVERRIDE):
+		ProjectSettings.set_setting(SETTING_PORT_OVERRIDE, WebSocketServer.DEFAULT_PORT)
+	ProjectSettings.save()
+
+
+func _setup_bind_ui() -> void:
+	if not _status_panel:
+		return
+	if _status_panel.has_method("set_config"):
+		_status_panel.set_config(_get_bind_mode(), _get_custom_bind_ip(), _get_port_override_enabled(), _get_port_override())
+	if _status_panel.has_signal("config_applied") and not _status_panel.config_applied.is_connected(_on_config_applied):
+		_status_panel.config_applied.connect(_on_config_applied)
+
+
+func _get_bind_mode() -> MCPEnums.BindMode:
+	return ProjectSettings.get_setting(SETTING_BIND_MODE, MCPEnums.BindMode.LOCALHOST) as MCPEnums.BindMode
+
+
+func _get_custom_bind_ip() -> String:
+	return str(ProjectSettings.get_setting(SETTING_CUSTOM_BIND_IP, ""))
+
+
+func _get_port_override_enabled() -> bool:
+	return bool(ProjectSettings.get_setting(SETTING_PORT_OVERRIDE_ENABLED, false))
+
+
+func _get_port_override() -> int:
+	var raw_value := ProjectSettings.get_setting(SETTING_PORT_OVERRIDE, WebSocketServer.DEFAULT_PORT)
+	var port := int(raw_value)
+	if port < MCPConstants.PORT_MIN or port > MCPConstants.PORT_MAX:
+		MCPLog.warn("Invalid port override '%s'; falling back to default port %d" % [str(raw_value), WebSocketServer.DEFAULT_PORT])
+		return WebSocketServer.DEFAULT_PORT
+	return port
+
+
+func _get_listen_port() -> int:
+	return _get_port_override() if _get_port_override_enabled() else WebSocketServer.DEFAULT_PORT
+
+
+func _resolve_bind_address() -> String:
+	match _get_bind_mode():
+		MCPEnums.BindMode.WSL:
+			var ip := _get_wsl_vethernet_ipv4()
+			if ip.is_empty():
+				MCPLog.warn("WSL bind mode selected but vEthernet (WSL) IPv4 was not found; falling back to %s" % MCPConstants.LOCALHOST_BIND_ADDRESS)
+				return MCPConstants.LOCALHOST_BIND_ADDRESS
+			return ip
+		MCPEnums.BindMode.CUSTOM:
+			var ip := _get_custom_bind_ip().strip_edges()
+			if ip.is_empty():
+				MCPLog.warn("Custom bind mode selected but no IP was configured; falling back to %s" % MCPConstants.LOCALHOST_BIND_ADDRESS)
+				return MCPConstants.LOCALHOST_BIND_ADDRESS
+			if not _is_valid_ipv4(ip):
+				MCPLog.warn("Custom bind mode selected but IP '%s' is not a valid IPv4 address; falling back to %s" % [ip, MCPConstants.LOCALHOST_BIND_ADDRESS])
+				return MCPConstants.LOCALHOST_BIND_ADDRESS
+			return ip
+		_:
+			return MCPConstants.LOCALHOST_BIND_ADDRESS
+
+
+func _is_valid_ipv4(ip: String) -> bool:
+	var s := ip.strip_edges()
+	if s.is_empty():
+		return false
+	var parts := s.split(".")
+	if parts.size() != 4:
+		return false
+	for p in parts:
+		if p.is_empty() or not p.is_valid_int():
+			return false
+		var n := int(p)
+		if n < 0 or n > 255:
+			return false
+	return true
+
+
+func _get_wsl_vethernet_ipv4() -> String:
+	# Autodetect "vEthernet (WSL)" IPv4 via PowerShell (Windows only).
+	if OS.get_name() != "Windows":
+		return ""
+
+	var output := []
+	# Use ErrorAction Stop + catch so failures return an empty string and don't emit noisy errors.
+	# Match any adapter alias that contains "WSL" to be resilient to name variations.
+	# Note: The wildcard pattern 'vEthernet*WSL*' provides flexibility but may match
+	# unexpected adapters in custom network configurations. Document expected adapter names.
+	# SECURITY NOTE: Keep this PowerShell command as a fixed string literal. Do NOT concatenate
+	# user input, project settings, environment variables, or any other external data into it,
+	# as that could introduce command injection vulnerabilities. If dynamic behavior is needed,
+	# implement strict validation and avoid direct string interpolation into PowerShell.
+	var cmd := "try { $ip = (Get-NetIPAddress -AddressFamily IPv4 -ErrorAction Stop | Where-Object { $_.InterfaceAlias -like 'vEthernet*WSL*' } | Select-Object -First 1 -ExpandProperty IPAddress); if ($ip) { $ip } else { '' } } catch { '' }"
+	var args := ["-NoProfile", "-Command", cmd]
+	var code := OS.execute("powershell", args, output, false)
+	if code != 0 or output.is_empty():
+		return ""
+
+	var text := String(output[0]).replace("\r", "")
+	for line in text.split("\n"):
+		var candidate := String(line).strip_edges()
+		if _is_valid_ipv4(candidate):
+			return candidate
+	return ""
+
+
+func _restart_server() -> void:
+	if _websocket_server:
+		_websocket_server.stop_server()
+	var bind := _resolve_bind_address()
+	var port := _get_listen_port()
+	_current_bind_address = bind
+	_current_bind_mode = _get_bind_mode()
+	var mode_name := MCPEnums.get_mode_name(_current_bind_mode)
+	if _websocket_server:
+		var err := _websocket_server.start_server(port, bind)
+		if err != OK:
+			_update_status("Failed to bind %s:%d [%s]" % [bind, port, mode_name])
+			return
+	_update_status("Waiting for connection... (bind %s:%d [%s])" % [bind, port, mode_name])
+	MCPLog.info("Server listening on %s:%d [%s]" % [bind, port, mode_name])
+
+
+func _apply_bind_settings(restart: bool) -> void:
+	_current_bind_address = _resolve_bind_address()
+	_current_bind_mode = _get_bind_mode()
+	if restart:
+		_restart_server()
+	else:
+		_update_status("Waiting for connection... (bind %s:%d [%s])" % [_current_bind_address, _get_listen_port(), MCPEnums.get_mode_name(_current_bind_mode)])
+
+
+func _on_config_applied(config: Dictionary) -> void:
+	ProjectSettings.set_setting(SETTING_BIND_MODE, config.get("bind_mode", MCPEnums.BindMode.LOCALHOST))
+	ProjectSettings.set_setting(SETTING_CUSTOM_BIND_IP, str(config.get("custom_ip", "")))
+	ProjectSettings.set_setting(SETTING_PORT_OVERRIDE_ENABLED, bool(config.get("port_override_enabled", false)))
+	ProjectSettings.set_setting(SETTING_PORT_OVERRIDE, int(config.get("port_override", WebSocketServer.DEFAULT_PORT)))
+	ProjectSettings.save()
+	_apply_bind_settings(true)
+
+
 func _ensure_game_bridge_autoload() -> void:
 	if not ProjectSettings.has_setting("autoload/" + GAME_BRIDGE_AUTOLOAD):
 		ProjectSettings.set_setting("autoload/" + GAME_BRIDGE_AUTOLOAD, GAME_BRIDGE_PATH)
@@ -75,8 +229,12 @@ func _on_command_received(id: String, command: String, params: Dictionary) -> vo
 
 
 func _on_client_connected() -> void:
-	_update_status("Connected")
-	MCPLog.info("Client connected")
+	var host_info := ""
+	if _websocket_server.get_connected_host():
+		host_info = " from %s:%d" % [_websocket_server.get_connected_host(), _websocket_server.get_connected_port()]
+	var bind_info := "(%s: %s:%d)" % [MCPEnums.get_mode_name(_current_bind_mode), _current_bind_address, _get_listen_port()]
+	_update_status("Connected%s %s" % [host_info, bind_info])
+	MCPLog.info("Client connected%s %s" % [host_info, bind_info])
 
 
 func _on_client_disconnected() -> void:

package/addon/ui/status_panel.gd

@@ -1,11 +1,60 @@
 @tool
 extends Control
 
-@onready var status_label: Label = $MarginContainer/HBoxContainer/StatusLabel
-@onready var status_icon: ColorRect = $MarginContainer/HBoxContainer/StatusIcon
+signal config_applied(config: Dictionary)
+
+@onready var status_label: Label = $MarginContainer/VBoxContainer/StatusRow/StatusLabel
+@onready var status_icon: ColorRect = $MarginContainer/VBoxContainer/StatusRow/StatusIcon
+@onready var bind_mode_option: OptionButton = $MarginContainer/VBoxContainer/SettingsGrid/BindModeOption
+@onready var custom_ip_label: Label = $MarginContainer/VBoxContainer/SettingsGrid/CustomIpLabel
+@onready var custom_ip_edit: LineEdit = $MarginContainer/VBoxContainer/SettingsGrid/CustomIpControls/CustomIpEdit
+@onready var port_override_label: Label = $MarginContainer/VBoxContainer/SettingsGrid/PortOverrideLabel
+@onready var port_override_enabled: CheckBox = $MarginContainer/VBoxContainer/SettingsGrid/PortOverrideControls/PortOverrideEnabled
+@onready var port_override_spin: SpinBox = $MarginContainer/VBoxContainer/SettingsGrid/PortOverrideControls/PortOverrideSpin
+@onready var apply_button: Button = $MarginContainer/VBoxContainer/ApplyRow/ApplyButton
+
+var _updating_ui := false
 
 
 func _ready() -> void:
+	if bind_mode_option:
+		_updating_ui = true
+		bind_mode_option.clear()
+		bind_mode_option.add_item("Localhost", 0)
+		bind_mode_option.add_item("WSL", 1)
+		bind_mode_option.add_item("Custom", 2)
+		bind_mode_option.selected = 0
+		_updating_ui = false
+		bind_mode_option.item_selected.connect(_on_bind_mode_selected)
+
+	if apply_button:
+		apply_button.pressed.connect(_on_apply_pressed)
+
+	if port_override_enabled:
+		port_override_enabled.toggled.connect(_on_port_override_toggled)
+	if port_override_spin:
+		port_override_spin.value = 6550
+
+	# Keyboard navigation / focus
+	_for_control_focus(bind_mode_option)
+	_for_control_focus(custom_ip_edit)
+	_for_control_focus(port_override_enabled)
+	_for_control_focus(port_override_spin)
+	_for_control_focus(apply_button)
+
+	# Set up focus chain: each control points to the next in sequence
+	if bind_mode_option and (custom_ip_edit or apply_button):
+		bind_mode_option.focus_next = custom_ip_edit.get_path() if custom_ip_edit else apply_button.get_path()
+	if custom_ip_edit and (port_override_enabled or apply_button):
+		custom_ip_edit.focus_next = port_override_enabled.get_path() if port_override_enabled else apply_button.get_path()
+	if port_override_enabled and (port_override_spin or apply_button):
+		port_override_enabled.focus_next = port_override_spin.get_path() if port_override_spin else apply_button.get_path()
+	if port_override_spin and (apply_button or bind_mode_option):
+		port_override_spin.focus_next = apply_button.get_path() if apply_button else bind_mode_option.get_path()
+	if apply_button and (bind_mode_option or apply_button):
+		apply_button.focus_next = bind_mode_option.get_path() if bind_mode_option else apply_button.get_path()
+
+	_update_controls_enabled()
 	set_status("Initializing...")
 
 
@@ -14,10 +63,123 @@ func set_status(status: String) -> void:
 		status_label.text = status
 
 	if status_icon:
-		match status:
-			"Connected":
-				status_icon.color = Color.GREEN
-			"Disconnected", "Waiting for connection...":
-				status_icon.color = Color.ORANGE
-			_:
-				status_icon.color = Color.GRAY
+		if status.begins_with("Connected"):
+			status_icon.color = Color.GREEN
+		elif status.begins_with("Disconnected") or status.begins_with("Waiting"):
+			status_icon.color = Color.ORANGE
+		else:
+			status_icon.color = Color.GRAY
+
+
+func set_bind_mode(mode: MCPEnums.BindMode) -> void:
+	if not bind_mode_option:
+		return
+	_updating_ui = true
+	match mode:
+		MCPEnums.BindMode.WSL:
+			bind_mode_option.select(1)
+		MCPEnums.BindMode.CUSTOM:
+			bind_mode_option.select(2)
+		_:
+			bind_mode_option.select(0)
+	_updating_ui = false
+	_update_controls_enabled()
+
+
+func get_bind_mode() -> MCPEnums.BindMode:
+	if not bind_mode_option:
+		return MCPEnums.BindMode.LOCALHOST
+	match bind_mode_option.selected:
+		1:
+			return MCPEnums.BindMode.WSL
+		2:
+			return MCPEnums.BindMode.CUSTOM
+		_:
+			return MCPEnums.BindMode.LOCALHOST
+
+
+func set_custom_ip(ip: String) -> void:
+	if not custom_ip_edit:
+		return
+	_updating_ui = true
+	custom_ip_edit.text = ip
+	_updating_ui = false
+
+
+func get_custom_ip() -> String:
+	return custom_ip_edit.text if custom_ip_edit else ""
+
+
+func _on_bind_mode_selected(_idx: int) -> void:
+	if _updating_ui:
+		return
+	_update_controls_enabled()
+
+
+func _on_port_override_toggled(_enabled: bool) -> void:
+	if _updating_ui:
+		return
+	_update_controls_enabled()
+
+
+func _on_apply_pressed() -> void:
+	config_applied.emit(get_config())
+
+
+func get_config() -> Dictionary:
+	return {
+		"bind_mode": get_bind_mode(),
+		"custom_ip": get_custom_ip(),
+		"port_override_enabled": port_override_enabled.button_pressed if port_override_enabled else false,
+		"port_override": int(port_override_spin.value) if port_override_spin else 6550,
+	}
+
+
+func set_config(bind_mode: MCPEnums.BindMode, custom_ip: String, port_enabled: bool, port_value: int) -> void:
+	set_bind_mode(bind_mode)
+	set_custom_ip(custom_ip)
+	if port_override_enabled:
+		_updating_ui = true
+		port_override_enabled.button_pressed = port_enabled
+		_updating_ui = false
+	if port_override_spin:
+		_updating_ui = true
+		port_override_spin.value = clamp(port_value, 1, 65535)
+		_updating_ui = false
+	_update_controls_enabled()
+
+
+func _for_control_focus(c: Control) -> void:
+	if not c:
+		return
+	c.focus_mode = Control.FOCUS_ALL
+
+
+func _unhandled_key_input(event: InputEvent) -> void:
+	if not (event is InputEventKey):
+		return
+	var e := event as InputEventKey
+	if not e.pressed or e.echo:
+		return
+	if e.keycode == KEY_ENTER or e.keycode == KEY_KP_ENTER:
+		if apply_button:
+			_on_apply_pressed()
+			get_viewport().set_input_as_handled()
+
+
+func _update_controls_enabled() -> void:
+	# Custom IP only editable in Custom mode
+	var custom_ip_enabled := get_bind_mode() == MCPEnums.BindMode.CUSTOM
+	if custom_ip_edit:
+		custom_ip_edit.editable = custom_ip_enabled
+		custom_ip_edit.modulate.a = 1.0 if custom_ip_enabled else 0.5
+	if custom_ip_label:
+		custom_ip_label.modulate.a = 1.0 if custom_ip_enabled else 0.5
+
+	# Port override controls
+	var port_enabled := port_override_enabled and port_override_enabled.button_pressed
+	if port_override_spin:
+		port_override_spin.editable = port_enabled
+		port_override_spin.modulate.a = 1.0 if port_enabled else 0.5
+	if port_override_label:
+		port_override_label.modulate.a = 1.0 if port_enabled else 0.5