@satelliteoflove/godot-mcp 3.10.0 → 3.10.1

package/addon/commands/input_commands.gd

@@ -3,6 +3,11 @@ extends MCPBaseCommand
 class_name MCPInputCommands
 
 const INPUT_TIMEOUT := 30.0
+# How long to wait for the game bridge to report it is ready to receive input
+# before giving up. The natural workflow is run -> immediately drive the game;
+# the session connects before the scene loads, so this short wait absorbs that
+# gap (usually under a second) instead of dispatching input into a void (#241).
+const READY_TIMEOUT := 10.0
 
 var _input_map_result: Dictionary = {}
 var _input_map_pending: bool = false
@@ -15,6 +20,9 @@ var _type_text_result: Dictionary = {}
 var _type_text_pending: bool = false
 
 
+const _BRIDGE_NOT_READY_MSG := "Game is running but its MCP bridge is not ready to receive input yet (no scene up, or the game just launched). This usually clears within a second of run — retry shortly."
+
+
 func get_commands() -> Dictionary:
 	return {
 		"get_input_map": get_input_map,
@@ -23,6 +31,23 @@ func get_commands() -> Dictionary:
 	}
 
 
+# Block until the running game's bridge reports it can consume input, bounded by
+# READY_TIMEOUT. Returns true once ready, false if the game stops or never comes
+# up in time. In the common case (game already running) this returns immediately
+# without waiting a frame. Gating input on this is the fix for #241: the debug
+# session connects before the main scene loads, so input dispatched on
+# has_active_session() alone lands in a game with nothing to receive it.
+func _await_bridge_ready(debugger_plugin) -> bool:
+	var start_time := Time.get_ticks_msec()
+	while not debugger_plugin.is_bridge_ready():
+		if not EditorInterface.is_playing_scene():
+			return false  # game stopped or crashed while we waited
+		await Engine.get_main_loop().process_frame
+		if (Time.get_ticks_msec() - start_time) / 1000.0 > READY_TIMEOUT:
+			return false
+	return true
+
+
 func get_input_map(_params: Dictionary) -> Dictionary:
 	if not EditorInterface.is_playing_scene():
 		return _get_editor_input_map()
@@ -113,8 +138,10 @@ func execute_input_sequence(params: Dictionary) -> Dictionary:
 		return _error("NOT_RUNNING", "No game is currently running")
 
 	var debugger_plugin = _plugin.get_debugger_plugin() if _plugin else null
-	if debugger_plugin == null or not debugger_plugin.has_active_session():
+	if debugger_plugin == null:
 		return _error("NO_SESSION", "No active debug session")
+	if not await _await_bridge_ready(debugger_plugin):
+		return _error("BRIDGE_NOT_READY", _BRIDGE_NOT_READY_MSG)
 
 	var max_end_time: float = 0.0
 	for input in inputs:
@@ -162,8 +189,10 @@ func type_text(params: Dictionary) -> Dictionary:
 		return _error("NOT_RUNNING", "No game is currently running")
 
 	var debugger_plugin = _plugin.get_debugger_plugin() if _plugin else null
-	if debugger_plugin == null or not debugger_plugin.has_active_session():
+	if debugger_plugin == null:
 		return _error("NO_SESSION", "No active debug session")
+	if not await _await_bridge_ready(debugger_plugin):
+		return _error("BRIDGE_NOT_READY", _BRIDGE_NOT_READY_MSG)
 
 	var timeout := max(INPUT_TIMEOUT, (text.length() * delay_ms / 1000.0) + 5.0)
 

package/addon/core/mcp_debugger_plugin.gd

@@ -10,8 +10,13 @@ signal input_map_received(actions: Array, error: String)
 signal input_sequence_completed(result: Dictionary)
 signal type_text_completed(result: Dictionary)
 signal game_response(message_type: String, data: Variant)
+signal bridge_ready()
 
 var _active_session_id: int = -1
+# True once the running game's bridge has announced it is ready to receive input
+# (its main scene is up). The debug session connects before the scene loads, so
+# has_active_session() alone is not enough to know input will land (#241).
+var _bridge_ready: bool = false
 var _pending_screenshot: bool = false
 var _pending_debug_output: bool = false
 var _pending_performance_metrics: bool = false
@@ -53,15 +58,30 @@ func _capture(message: String, data: Array, session_id: int) -> bool:
 		"godot_mcp:game_response":
 			_handle_game_response(data)
 			return true
+		"godot_mcp:bridge_ready":
+			_handle_bridge_ready(session_id)
+			return true
 	return false
 
 
+func _handle_bridge_ready(session_id: int) -> void:
+	# Only the active session's bridge counts; ignore a late message from a prior
+	# run (a new _setup_session has already reset the flag for the current one).
+	if session_id != _active_session_id:
+		return
+	_bridge_ready = true
+	bridge_ready.emit()
+
+
 func _setup_session(session_id: int) -> void:
 	_active_session_id = session_id
+	# New game session: its bridge has not announced readiness yet.
+	_bridge_ready = false
 
 
 func _session_stopped() -> void:
 	_active_session_id = -1
+	_bridge_ready = false
 	if _pending_screenshot:
 		_pending_screenshot = false
 		screenshot_received.emit(false, "", 0, 0, "Game session ended")
@@ -97,6 +117,13 @@ func has_active_session() -> bool:
 	return true
 
 
+# True only once the running game's bridge has reported its main scene is up and
+# can consume input. Input commands gate on this (not just has_active_session) so
+# a sequence injected right after run is not dispatched into a half-booted game.
+func is_bridge_ready() -> bool:
+	return _bridge_ready and has_active_session()
+
+
 func request_screenshot(max_width: int = 1024, quality: float = 0.75) -> void:
 	if _active_session_id < 0:
 		screenshot_received.emit(false, "", 0, 0, "No active game session")

package/addon/game_bridge/mcp_game_bridge.gd

@@ -5,10 +5,20 @@ const DEFAULT_MAX_WIDTH := 1024
 const DEFAULT_JPEG_QUALITY := 0.75
 const Onscreen := preload("onscreen.gd")
 
+# Cap on frames waited for the main scene to appear before announcing ready
+# anyway. The scene is normally added within a frame or two of the bridge
+# autoload's _ready; the cap only matters for a scene-less run (a SceneTree-only
+# tool), so it never blocks readiness forever. ~10s at 60 fps.
+const READY_SCENE_WAIT_FRAMES := 600
+
 var _logger: _MCPGameLogger
 var _profiler: MCPFrameProfiler
 var _sampler: MCPRuntimeStateSampler
 
+# Set once the bridge has told the editor the game is ready to drive. Guards the
+# announcement against firing twice and lets the headless test observe it.
+var _ready_announced := false
+
 
 func _ready() -> void:
 	# The bridge must keep processing while the scene tree is paused. Input
@@ -39,6 +49,10 @@ func _ready() -> void:
 		_engage_freeze()
 		MCPLog.info("Game bridge: launched frozen")
 
+	# Tell the editor when the game is actually drivable, so input injected right
+	# after `run` is not silently dropped into a half-booted game (see #241).
+	_announce_bridge_ready_when_drivable()
+
 
 func _exit_tree() -> void:
 	# Guaranteed cleanup: never leave an action latched when the bridge node
@@ -50,6 +64,35 @@ func _exit_tree() -> void:
 			EngineDebugger.unregister_profiler("mcp_frame_profiler")
 
 
+# The bridge autoload's _ready runs BEFORE the main scene is added to the tree,
+# so the debug session is live (and the editor sees has_active_session) while
+# current_scene is still null. Input injected in that window is dispatched into a
+# game that has nothing to consume it — reported as executed, but a silent no-op
+# (#241). Wait for the scene to exist plus one frame (so its own _ready/input
+# wiring has run), then announce readiness; the editor gates input on this signal.
+func _announce_bridge_ready_when_drivable() -> void:
+	var tree := get_tree()
+	if tree == null:
+		return
+	var frames := 0
+	while tree.current_scene == null and frames < READY_SCENE_WAIT_FRAMES:
+		await tree.process_frame
+		frames += 1
+	# One more frame so a freshly-added scene has had its first _ready/process pass.
+	# process_frame fires even while paused, so launch-frozen runs still report ready.
+	await tree.process_frame
+	var scene_path := tree.current_scene.scene_file_path if tree.current_scene else ""
+	_emit_bridge_ready(scene_path)
+
+
+func _emit_bridge_ready(scene_path: String) -> void:
+	if _ready_announced:
+		return
+	_ready_announced = true
+	EngineDebugger.send_message("godot_mcp:bridge_ready", [scene_path])
+	MCPLog.info("Game bridge: ready to drive (%s)" % scene_path)
+
+
 func _process(delta: float) -> void:
 	_game_time_process(delta)
 	_sequence_process()

package/addon/plugin.cfg

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@satelliteoflove/godot-mcp",
-  "version": "3.10.0",
+  "version": "3.10.1",
   "description": "MCP server for Godot Engine integration",
   "type": "module",
   "main": "dist/index.js",