gdharness 0.5.7 → 0.5.8

package/build/cli.js

@@ -15821,7 +15821,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "runtime_input",
-      description: "Input to the running game: a whole click on a Control named by path, or a raw action, key, mouse button or mouse motion. All of it works headless, where the window is 64 by 64 and the GUI only takes what is inside it.",
+      description: "Input to the running game: a whole click on a Control named by path, typing into whatever has the focus, or a raw action, key, mouse button or mouse motion. All of it works headless, where the window is 64 by 64 and the GUI only takes what is inside it.",
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
         nodePath: { type: "string", description: "click: the Control to click, at its centre." },
@@ -15829,6 +15829,10 @@ var init_tool_definitions = __esm(() => {
         pressed: { type: "boolean", description: "Press or release. Default true." },
         strength: { type: "number", description: "action: 0 to 1. Default 1." },
         keycode: { type: "string", description: 'key: the key name, such as "Space" or "A".' },
+        text: {
+          type: "string",
+          description: "text: what to type. A newline is Enter and a tab is Tab."
+        },
         shift: { type: "boolean" },
         ctrl: { type: "boolean" },
         alt: { type: "boolean" },
@@ -15851,6 +15855,10 @@ var init_tool_definitions = __esm(() => {
         },
         action: { summary: "press or release an action", requires: ["action"] },
         key: { summary: "press or release a key", requires: ["keycode"] },
+        text: {
+          summary: "type a string wherever the focus is, a character at a time",
+          requires: ["text"]
+        },
         mouse_click: { summary: "one mouse button event at a position", requires: ["x", "y"] },
         mouse_motion: { summary: "move the mouse to a position", requires: ["x", "y"] }
       }
@@ -38469,6 +38477,7 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 | Where a control is, and whether it is visible | \`runtime_inspect\` \`find\`, \`rect\` |
 | What a property reads right now | \`runtime_inspect\` \`property\`, \`runtime_invoke\` |
 | Press a button | \`runtime_input click\`, which says what was under the pointer |
+| Fill in a field | \`runtime_input click\` on it, then \`runtime_input text\` |
 | Wait for something | \`runtime_wait\`, never a sleep |
 | A picture, for a person who asked to see one | \`runtime_capture\` |
 

package/build/godot/addons/auto_reload/auto_reload.gd.uid

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

package/build/godot/addons/gdharness_editor/bridge_client.gd

@@ -19,7 +19,8 @@ var server_url: String = DEFAULT_URL
 var _is_connected: bool = false
 var _reconnect_timer: Timer
 var _current_reconnect_delay: float = RECONNECT_DELAY
-var _should_reconnect: bool = true
+## Nothing reconnects until somebody has asked to connect once.
+var _should_reconnect: bool = false
 var _project_path: String
 var _initialized: bool = false
 
@@ -43,6 +44,11 @@ func _process(_delta: float) -> void:
 	if socket.get_ready_state() == WebSocketPeer.STATE_CLOSED:
 		if _is_connected:
 			_handle_disconnect()
+		elif _should_reconnect and _reconnect_timer.is_stopped():
+			# A connection refused never opened, so it reaches CLOSED without passing through
+			# _handle_disconnect and nothing would ask again. An editor opened before the server
+			# is the ordinary way that happens, and it then sat there for the rest of the day.
+			_schedule_reconnect()
 		return
 
 	socket.poll()

package/build/godot/addons/gdharness_editor/bridge_client.gd.uid

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

package/build/godot/addons/gdharness_editor/plugin.gd.uid

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

package/build/godot/addons/gdharness_editor/tool_executor.gd.uid

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

package/build/godot/addons/gdharness_editor/tools/animation_tools.gd.uid

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

package/build/godot/addons/gdharness_editor/tools/play_tools.gd.uid

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

package/build/godot/addons/gdharness_editor/tools/resource_tools.gd.uid

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

package/build/godot/addons/gdharness_editor/tools/scene_tools.gd.uid

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

package/build/godot/addons/gdharness_runtime/runtime_autoload.gd

@@ -66,6 +66,7 @@ func _init() -> void:
 		"capture_viewport": _capture.capture_viewport,
 		"inject_action": _input.inject_action,
 		"inject_key": _input.inject_key,
+		"inject_text": _input.inject_text,
 		"inject_mouse_click": _input.inject_mouse_click,
 		"inject_mouse_motion": _input.inject_mouse_motion,
 		"click": _input.click,

package/build/godot/addons/gdharness_runtime/runtime_autoload.gd.uid

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

package/build/godot/addons/gdharness_runtime/runtime_capture.gd.uid

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

package/build/godot/addons/gdharness_runtime/runtime_input.gd

@@ -5,6 +5,13 @@ extends RefCounted
 
 const Values = preload("runtime_values.gd")
 
+## The distance from a capital letter to its small one in Unicode. A keycode holds the capital.
+const TO_SMALL: int = 32
+
+## The two characters a field reads as keys rather than as text.
+const NEWLINE: int = 10
+const TAB: int = 9
+
 var _host: Node
 var _values: Values
 
@@ -69,6 +76,12 @@ func inject_key(params: Dictionary) -> Dictionary:
 	event.ctrl_pressed = bool(params.get("ctrl", false))
 	event.alt_pressed = bool(params.get("alt", false))
 
+	# The fourth thing a real event carries, and the only one a text field reads: LineEdit and
+	# TextEdit insert `unicode` and never consult the keycode, so an injected key could press any
+	# action in the map and still type nothing into a search box. Godot's keycodes for printable
+	# keys are the code points themselves, which is what makes this a mapping and not a table.
+	event.unicode = _glyph_of(event.keycode, event.shift_pressed)
+
 	Input.parse_input_event(event)
 
 	return {
@@ -79,10 +92,73 @@ func inject_key(params: Dictionary) -> Dictionary:
 		"shift": event.shift_pressed,
 		"ctrl": event.ctrl_pressed,
 		"alt": event.alt_pressed,
+		"unicode": event.unicode,
 		"pressed": pressed
 	}
 
 
+## Types [param text] wherever the focus is, one key event per character.
+##
+## A key on its own cannot do this and should not try: which character a key produces is the
+## keyboard layout's business, and shift over a digit is an exclamation mark on one layout and
+## something else on the next. Given the character instead there is nothing to guess, so a field
+## can be filled with anything a player could type, this project's own two typefaces included.
+##
+## A newline and a tab are the two characters a field reads as keys rather than as text, so they
+## are sent as those keys and carry no character of their own: typing a name and submitting it is
+## one call rather than two.
+##
+## Pushed into the viewport for the reason [method click] is, and it matters more here: the focus
+## is what decides where a character lands, so a caller that clicked a field and then typed would
+## otherwise have both waiting in the same queue with nothing said about the order.
+func inject_text(params: Dictionary) -> Dictionary:
+	var text: String = String(params.get("text", ""))
+	if text.is_empty():
+		return {"type": "error", "message": "text required"}
+
+	var viewport: Viewport = _host.get_tree().root
+	for index: int in text.length():
+		var down: InputEventKey = _typed(text.unicode_at(index))
+		viewport.push_input(down)
+		# The release as well, so nothing is left held down behind the caller.
+		var up: InputEventKey = down.duplicate()
+		up.pressed = false
+		viewport.push_input(up)
+
+	return {"type": "input_injected", "input_type": "text", "text": text, "characters": text.length()}
+
+
+## The key press that produces [param glyph], as a keyboard would send it.
+func _typed(glyph: int) -> InputEventKey:
+	var event: InputEventKey = InputEventKey.new()
+	event.pressed = true
+	if glyph == NEWLINE:
+		event.keycode = KEY_ENTER
+	elif glyph == TAB:
+		event.keycode = KEY_TAB
+	else:
+		var capital: int = String.chr(glyph).to_upper().unicode_at(0)
+		event.keycode = capital as Key
+		event.shift_pressed = capital != glyph
+		event.unicode = glyph
+	event.physical_keycode = event.keycode
+	event.key_label = event.keycode
+	return event
+
+
+## The character a key produces, or nothing for a key that produces none.
+##
+## Godot's keycodes below [constant KEY_SPECIAL] are the Unicode code points of the keys that
+## print something, so the mapping is the value itself. Letters are held as their capitals, which
+## is the one place the shift a caller asked for changes the answer rather than the key.
+func _glyph_of(keycode: Key, shifted: bool) -> int:
+	if keycode >= KEY_SPECIAL:
+		return 0
+	if keycode >= KEY_A and keycode <= KEY_Z and not shifted:
+		return keycode + TO_SMALL
+	return keycode
+
+
 ## A point the tool schema sends as two flat numbers, or the older form of one [x, y] value.
 ## Answers a Vector2, or the String that says what was wrong with it.
 func _read_point(params: Dictionary, x_key: String, y_key: String, pair_key: String) -> Variant:

package/build/godot/addons/gdharness_runtime/runtime_input.gd.uid

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

package/build/godot/addons/gdharness_runtime/runtime_queries.gd.uid

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

package/build/godot/addons/gdharness_runtime/runtime_values.gd

@@ -28,7 +28,16 @@ const SERIALISERS: Dictionary = {
 
 ## Converts a Godot value into something JSON can carry. A type with no entry in the table
 ## passes through as itself, which is what the JSON-native ones want.
+##
+## A method or property typed as a class answers a null with a Variant of type OBJECT that has
+## nothing behind it, and so does one whose object has been freed. Asking either for its class is
+## a script error, and a script error here costs far more than the one answer: the request is
+## never replied to at all, and an editor playing the game stops it dead on the error, so every
+## question after it times out as well. `find_child` for a name nothing has cost a whole session
+## that way.
 func serialize(value: Variant) -> Variant:
+	if typeof(value) == TYPE_OBJECT and not is_instance_valid(value):
+		return null
 	var serialiser: String = SERIALISERS.get(typeof(value), "")
 	return call(serialiser, value) if not serialiser.is_empty() else value
 

package/build/godot/addons/gdharness_runtime/runtime_values.gd.uid

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

package/build/godot/addons/gdharness_runtime/runtime_waits.gd.uid

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

package/build/godot/operations/serialisation.gd

@@ -27,7 +27,15 @@ const SERIALISERS: Dictionary = {
 
 # Converts a Godot value into something JSON can carry. A type with no entry in the table
 # passes through as itself, which is what the JSON-native ones want.
+#
+# A property that holds no object is Object-typed and null rather than nil, which is most of what
+# a node's property list is, and an object that has been freed is the same shape again. Both are
+# refused here rather than inside _serialize_object, because a freed one never reaches it: the
+# call itself fails on the argument, with "previously freed is not a subclass of the expected
+# argument class", and a guard behind that is a guard that never runs.
 func serialize_value(value: Variant) -> Variant:
+	if typeof(value) == TYPE_OBJECT and not is_instance_valid(value):
+		return null
 	var serialiser: String = SERIALISERS.get(typeof(value), "")
 	return call(serialiser, value) if not serialiser.is_empty() else value
 
@@ -140,12 +148,7 @@ func _serialize_dictionary(value: Dictionary) -> Dictionary:
 
 
 # A pathless Resource says so rather than inventing an empty path for the caller to load.
-#
-# A property that holds no object is Object-typed and null rather than nil, which is most of
-# what a node's property list is, so this is the branch that runs the most.
 func _serialize_object(value: Object) -> Variant:
-	if not is_instance_valid(value):
-		return null
 	if not value is Resource:
 		return {"_type": "Object", "class": value.get_class()}
 	var resource: Resource = value

package/build/index.js

@@ -28251,7 +28251,7 @@ var TOOL_SPECS = [
   },
   {
     name: "runtime_input",
-    description: "Input to the running game: a whole click on a Control named by path, or a raw action, key, mouse button or mouse motion. All of it works headless, where the window is 64 by 64 and the GUI only takes what is inside it.",
+    description: "Input to the running game: a whole click on a Control named by path, typing into whatever has the focus, or a raw action, key, mouse button or mouse motion. All of it works headless, where the window is 64 by 64 and the GUI only takes what is inside it.",
     parameters: {
       projectPath: RUNNING_PROJECT_PATH,
       nodePath: { type: "string", description: "click: the Control to click, at its centre." },
@@ -28259,6 +28259,10 @@ var TOOL_SPECS = [
       pressed: { type: "boolean", description: "Press or release. Default true." },
       strength: { type: "number", description: "action: 0 to 1. Default 1." },
       keycode: { type: "string", description: 'key: the key name, such as "Space" or "A".' },
+      text: {
+        type: "string",
+        description: "text: what to type. A newline is Enter and a tab is Tab."
+      },
       shift: { type: "boolean" },
       ctrl: { type: "boolean" },
       alt: { type: "boolean" },
@@ -28281,6 +28285,10 @@ var TOOL_SPECS = [
       },
       action: { summary: "press or release an action", requires: ["action"] },
       key: { summary: "press or release a key", requires: ["keycode"] },
+      text: {
+        summary: "type a string wherever the focus is, a character at a time",
+        requires: ["text"]
+      },
       mouse_click: { summary: "one mouse button event at a position", requires: ["x", "y"] },
       mouse_motion: { summary: "move the mouse to a position", requires: ["x", "y"] }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "0.5.7",
+  "version": "0.5.8",
   "mcpName": "io.github.Aureliolo/gdharness",
   "description": "A harness for driving a Godot 4 project from an agent: editor addons, a runtime bridge into the running game, an MCP server in front of them, and a CLI that installs and diagnoses the Godot side.",
   "type": "module",