gdharness 0.6.2 → 0.6.4

package/build/cli.js

@@ -157,8 +157,8 @@ function runArguments(options) {
   }
   return args;
 }
-function editorArguments(projectPath) {
-  return ["-e", "--path", projectPath];
+function editorArguments(projectPath, ports) {
+  return ["-e", "--path", projectPath, "--lsp-port", String(ports.lsp), "--dap-port", String(ports.dap)];
 }
 function userDataIn(home, variables = process.env) {
   const moved = ["APPDATA", "XDG_DATA_HOME"];
@@ -15834,12 +15834,12 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "runtime_input",
-      description: "Input to the running game: a whole click on a Control or a 3D node 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.",
+      description: "Input to the running game: a whole click on a Control or a 3D node named by path, an item chosen out of a menu, 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, or the 3D node to click, where it is drawn."
+          description: "click: the Control to click, at its centre, or the 3D node to click, where it is drawn. choose: the PopupMenu, or the OptionButton or MenuButton in front of one."
         },
         action: { type: "string", description: "action: the InputMap action name." },
         pressed: { type: "boolean", description: "Press or release. Default true." },
@@ -15847,7 +15847,11 @@ var init_tool_definitions = __esm(() => {
         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."
+          description: "text: what to type. A newline is Enter and a tab is Tab. choose: the item to take, by what it says."
+        },
+        index: {
+          type: "number",
+          description: "choose: the item to take, by where it is in the list, when text will not do."
         },
         shift: { type: "boolean" },
         ctrl: { type: "boolean" },
@@ -15869,6 +15873,10 @@ var init_tool_definitions = __esm(() => {
           summary: "press and release on a Control, a frame apart, and answer with what was under the pointer and what became of the control: in_tree, removed or freed. A control out of sight inside a ScrollContainer is scrolled to first, and scrolled_into_view says whether the view moved. A 3D node is clicked where it is drawn, and landed then says the interface did not swallow the press",
           requires: ["nodePath"]
         },
+        choose: {
+          summary: "take an item out of a menu, by what it says or by where it is in the list. A menu's items are drawn rather than built, so there is nothing to click: the item takes the focus and Enter presses it, which is the engine's own path and needs no window. Answers with what was chosen and what the button in front of it shows now",
+          requires: ["nodePath"]
+        },
         action: { summary: "press or release an action", requires: ["action"] },
         key: { summary: "press or release a key", requires: ["keycode"] },
         text: {
@@ -30783,10 +30791,11 @@ var init_framing = __esm(() => {
 });
 
 // src/ports.ts
-function portFromEnv(variable, fallback) {
+import { createServer } from "node:net";
+function portFromEnvOrNull(variable) {
   const raw = process.env[variable]?.trim();
   if (!raw) {
-    return fallback;
+    return null;
   }
   const parsed = Number.parseInt(raw, 10);
   if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65535 || String(parsed) !== raw) {
@@ -30794,6 +30803,36 @@ function portFromEnv(variable, fallback) {
   }
   return parsed;
 }
+function portFromEnv(variable, fallback) {
+  return portFromEnvOrNull(variable) ?? fallback;
+}
+async function freePort(preferred, host = "127.0.0.1") {
+  const asked = await bindable(preferred, host);
+  if (asked !== null) {
+    return asked;
+  }
+  const spare = await bindable(0, host);
+  if (spare === null) {
+    throw new Refusal2(`No port could be bound on ${host}.`);
+  }
+  return spare;
+}
+function bindable(port, host) {
+  return new Promise((resolve) => {
+    const probe = createServer();
+    probe.once("error", () => {
+      resolve(null);
+    });
+    probe.once("listening", () => {
+      const bound = probe.address();
+      const taken = typeof bound === "object" && bound !== null ? bound.port : port;
+      probe.close(() => {
+        resolve(taken);
+      });
+    });
+    probe.listen(port, host);
+  });
+}
 var init_ports = __esm(() => {
   init_errors();
 });
@@ -34181,6 +34220,9 @@ function resolveDefaultBridgeHost() {
   const host = process.env["GDHARNESS_BRIDGE_HOST"]?.trim();
   return host === undefined || host === "" ? DEFAULT_HOST : host;
 }
+function servedPort(said) {
+  return typeof said === "number" && Number.isInteger(said) && said > 0 && said <= 65535 ? said : undefined;
+}
 function getDefaultBridge(mayMove = false) {
   defaultBridge ??= new GodotBridge(resolveDefaultBridgePort(), resolveDefaultBridgeHost(), DEFAULT_TIMEOUT_MS, mayMove);
   return defaultBridge;
@@ -34321,6 +34363,9 @@ var init_godot_bridge = __esm(() => {
         lastPongAt: this.connectionInfo?.lastPongAt,
         addonVersion: this.connectionInfo?.addonVersion,
         editorPid: this.connectionInfo?.editorPid,
+        lspPort: this.connectionInfo?.lspPort,
+        dapPort: this.connectionInfo?.dapPort,
+        debugPort: this.connectionInfo?.debugPort,
         pendingRequests: this.pendingRequests.size,
         queuedResources: this.resourceQueues.size
       };
@@ -34454,6 +34499,9 @@ var init_godot_bridge = __esm(() => {
             this.connectionInfo.projectPath = message.project_path;
             this.connectionInfo.addonVersion = message.addon_version ?? "";
             this.connectionInfo.editorPid = message.editor_pid;
+            this.connectionInfo.lspPort = servedPort(message.lsp_port);
+            this.connectionInfo.dapPort = servedPort(message.dap_port);
+            this.connectionInfo.debugPort = servedPort(message.debug_port);
             this.log("info", `Godot ready: ${message.project_path}`);
             this.emitBridgeEvent("godot_connected", { projectPath: message.project_path });
           }
@@ -35360,10 +35408,10 @@ function asToolResponse(payload) {
     ]
   };
 }
-function normalizeLSPError(error) {
+function normalizeLSPError(error, port) {
   if (error instanceof Error) {
     if (error.message.includes("ECONNREFUSED") || error.message.includes("Failed to connect to Godot LSP") || error.message.includes("socket closed")) {
-      return `Godot LSP is unavailable on port ${portFromEnv("GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT)}. Start the Godot editor and enable Language Server in Editor Settings, or set GDHARNESS_LSP_PORT to the port it serves.`;
+      return `Godot LSP is unavailable on port ${port}. Start the Godot editor and enable Language Server in Editor Settings, or set GDHARNESS_LSP_PORT to the port it serves.`;
     }
     return error.message;
   }
@@ -35441,7 +35489,7 @@ async function handleLSPTool(client, toolName, args) {
     }
   } catch (error) {
     return asToolResponse({
-      error: normalizeLSPError(error)
+      error: normalizeLSPError(error, client.port)
     });
   }
 }
@@ -36307,12 +36355,23 @@ class GodotServer {
       case "runtime_capture":
         return await this.handleRuntimeCommand(op === "screenshot" ? "capture_screenshot" : "capture_viewport", args);
       case "runtime_input":
-        return op === "click" ? await this.handleRuntimeCommand("click", {
-          projectPath: args["projectPath"],
-          path: readNonEmptyString(args, "nodePath") ?? "",
-          button: readString(args, "button") ?? "left",
-          double: readBoolean(args, "doubleClick") ?? false
-        }) : await this.handleRuntimeCommand(`inject_${op}`, args);
+        if (op === "click") {
+          return await this.handleRuntimeCommand("click", {
+            projectPath: args["projectPath"],
+            path: readNonEmptyString(args, "nodePath") ?? "",
+            button: readString(args, "button") ?? "left",
+            double: readBoolean(args, "doubleClick") ?? false
+          });
+        }
+        if (op === "choose") {
+          return await this.handleRuntimeCommand("choose", {
+            projectPath: args["projectPath"],
+            path: readNonEmptyString(args, "nodePath") ?? "",
+            text: readString(args, "text") ?? "",
+            ...args["index"] === undefined ? {} : { index: args["index"] }
+          });
+        }
+        return await this.handleRuntimeCommand(`inject_${op}`, args);
       case "runtime_wait":
         return await this.handleRuntimeWait(op, args);
       case "debug_breakpoint": {
@@ -36393,7 +36452,7 @@ class GodotServer {
       return {
         ok: false,
         response: this.createErrorResponse(`The editor is playing the game but its debug adapter did not answer: ${errorMessage(error)}`, [
-          "Godot serves the debug adapter on 6006 unless --dap-port says otherwise",
+          `This asked on port ${this.dap().port}, which is where the connected editor says it serves`,
           "GDHARNESS_DAP_PORT points this server at another one"
         ])
       };
@@ -36760,7 +36819,8 @@ class GodotServer {
     if (payload["error"] !== undefined) {
       const reason = payload["error"];
       return this.createErrorResponse(`Diagnostics unavailable: ${typeof reason === "string" ? reason : JSON.stringify(reason)}`, [
-        "Ensure the Godot editor is running with its language server enabled, on port 6005 or on the port GDHARNESS_LSP_PORT names"
+        `Ensure the Godot editor is running with its language server enabled, on port ${this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT)}`,
+        "GDHARNESS_LSP_PORT points this server at another one"
       ]);
     }
     const diagnostics = readArray(payload, "diagnostics") ?? [];
@@ -36777,16 +36837,33 @@ class GodotServer {
     });
   }
   async handleLSP(toolName, args) {
-    this.lspClient ??= new GodotLSPClient;
+    const port = this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT);
+    if (this.lspClient !== null && this.lspClient.port !== port) {
+      await this.lspClient.disconnect();
+      this.lspClient = null;
+    }
+    this.lspClient ??= new GodotLSPClient(port);
     return handleLSPTool(this.lspClient, toolName, args);
   }
   async handleDAP(toolName, args) {
     return handleDAPTool(this.dap(), toolName, args);
   }
   dap() {
-    this.dapClient ??= new GodotDAPClient;
+    const port = this.editorServes("dapPort", "GDHARNESS_DAP_PORT", DEFAULT_DAP_PORT);
+    if (this.dapClient !== null && this.dapClient.port !== port) {
+      this.dapClient = null;
+    }
+    this.dapClient ??= new GodotDAPClient(port);
     return this.dapClient;
   }
+  editorServes(field, variable, fallback) {
+    const named = portFromEnvOrNull(variable);
+    if (named !== null) {
+      return named;
+    }
+    const status = this.godotBridge.getStatus();
+    return (status.connected ? status[field] : undefined) ?? fallback;
+  }
   getEditorStatusPayload() {
     const status = this.godotBridge.getStatus();
     const isPortConflict = this.bridgeStartupError?.includes("EADDRINUSE") ?? false;
@@ -36814,7 +36891,8 @@ class GodotServer {
       const answer = await this.godotBridge.invokeTool("playing_status", {});
       return {
         playing: readBoolean(asParams(answer), "playing") ?? false,
-        scene: readString(asParams(answer), "scenePath") ?? ""
+        scene: readString(asParams(answer), "scenePath") ?? "",
+        debugPort: readNumber(asParams(answer), "debugPort")
       };
     } catch {
       return null;
@@ -36832,15 +36910,19 @@ class GodotServer {
         problem: reply.ok ? null : reply.message
       };
     }));
+    const playing = await this.editorPlayingState();
     return this.jsonTextResponse({
-      editor: this.getEditorStatusPayload(),
+      editor: {
+        ...this.getEditorStatusPayload(),
+        debugPort: playing?.debugPort ?? this.godotBridge.getStatus().debugPort
+      },
       godot: {
         path: godotPath,
         version: godotPath === null ? null : await this.godotVersion(godotPath)
       },
       game: {
         processActive: this.activeProcess !== null,
-        playingInEditor: await this.editorPlayingState(),
+        playingInEditor: playing,
         runtimeConnected: games.some((game) => game.reachable),
         runtimes: games
       }
@@ -36899,10 +36981,10 @@ class GodotServer {
       return project.response;
     }
     if (this.godotBridge.isConnected()) {
-      return this.createErrorResponse("An editor is already connected to this server, and a second one would take the language server and debug adapter ports from it.", [
+      return this.createErrorResponse("An editor is already connected to this server.", [
         "editor_status says which editor is answering, and for which project",
         "editor_launch restart replaces the connected editor rather than joining it",
-        "Close the open editor first if the new project is the one you want"
+        "Another project wants its own gdharness server, which is its own harness session"
       ]);
     }
     const engine = await this.engine();
@@ -36910,10 +36992,16 @@ class GodotServer {
       return engine.response;
     }
     this.logDebug(`Launching Godot editor for project: ${project.value.path}`);
-    const editor = spawn(engine.value, editorArguments(project.value.path), {
+    const ports = await this.portsForAnEditor();
+    const editor = spawn(engine.value, editorArguments(project.value.path, ports), {
       stdio: "ignore",
       detached: true,
-      env: { ...process.env, GDHARNESS_RUNTIME_DIR: runtimeDirectory() }
+      env: {
+        ...process.env,
+        GDHARNESS_RUNTIME_DIR: runtimeDirectory(),
+        GDHARNESS_LSP_PORT: String(ports.lsp),
+        GDHARNESS_DAP_PORT: String(ports.dap)
+      }
     });
     const started = await new Promise((resolve) => {
       editor.once("spawn", () => {
@@ -36930,9 +37018,16 @@ class GodotServer {
     return this.jsonTextResponse({
       launched: true,
       pid: editor.pid ?? null,
-      projectPath: project.value.path
+      projectPath: project.value.path,
+      lspPort: ports.lsp,
+      dapPort: ports.dap
     });
   }
+  async portsForAnEditor() {
+    const lsp = portFromEnvOrNull("GDHARNESS_LSP_PORT") ?? await freePort(DEFAULT_LSP_PORT);
+    const dap = portFromEnvOrNull("GDHARNESS_DAP_PORT") ?? await freePort(DEFAULT_DAP_PORT);
+    return { lsp, dap };
+  }
   async handleRunProject(args, op) {
     const project = this.project(args);
     if (!project.ok) {
@@ -37000,7 +37095,7 @@ class GodotServer {
       await this.dap().connect();
     } catch (error) {
       return this.createErrorResponse(`The editor is connected but its debug adapter is not: ${errorMessage(error)}`, [
-        "Godot serves the debug adapter on 6006 unless --dap-port says otherwise",
+        `This asked on port ${this.dap().port}, which is where the connected editor says it serves`,
         "GDHARNESS_DAP_PORT points this server at another one"
       ]);
     }
@@ -37022,6 +37117,7 @@ class GodotServer {
       through: "editor",
       scene: scene === null ? "the main scene" : `res://${scene}`,
       refreshedClasses,
+      debugPort: readNumber(asParams(JSON.parse(answer.content[0]?.text ?? "{}")), "debugPort"),
       message: "The editor is playing it, so its debugger holds it: the debug_* tools can reach it, " + "editor_output reads its console through the debug adapter, and editor_run stop ends it."
     });
   }
@@ -37204,7 +37300,7 @@ class GodotServer {
   async handleRuntimeCommand(command, args, timeoutMs = this.runtimeTimeoutMs()) {
     const { op: _op, projectPath, ...params } = asParams(args);
     const announced = runtimesAnnounced();
-    const choice = chooseRuntime(announced.running, typeof projectPath === "string" ? projectPath : undefined, announced.unspoken);
+    const choice = chooseRuntime(announced.running, typeof projectPath === "string" ? projectPath : this.ownProject ?? undefined, announced.unspoken);
     if ("problem" in choice) {
       return this.createErrorResponse(choice.problem);
     }
@@ -37312,6 +37408,7 @@ var init_server3 = __esm(() => {
   init_junit();
   init_lsp_client();
   init_paths();
+  init_ports();
   init_project_scan();
   init_resources();
   init_runtime_client();
@@ -38635,6 +38732,9 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 - Read \`editor_output\` after every run. It returns the engine's errors and warnings as entries
   with their backtraces, and a \`clean\` verdict, so a run that printed an error is one call away
   from being known.
+- One server, one editor. A second project is a second harness session with its own server, and
+  that works: each editor is opened on its own language server and debug adapter ports, and says
+  where it serves. Two editors on one project is the thing to refuse.
 
 ## Measuring a running game
 
@@ -38645,6 +38745,7 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 | 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\` |
 | Click somebody standing in a 3D room | \`runtime_input click\` on the Node3D, which aims at what it draws |
+| Pick something out of a dropdown | \`runtime_input choose\` on it, by what the item says |
 | Where a 3D node is on screen | \`runtime_inspect\` \`rect\`, rather than unprojecting by hand |
 | Wait for something | \`runtime_wait\`, never a sleep |
 | A picture, for a person who asked to see one | \`runtime_capture\` |

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

@@ -18,6 +18,17 @@ const ANNOUNCE_PROTOCOL: int = 1
 const RECONNECT_DELAY: float = 3.0
 const MAX_RECONNECT_DELAY: float = 30.0
 
+## Where Godot keeps the three ports an editor serves. None of them is per editor: the settings
+## file is one for every editor on the machine, so two open at once want the same three and the
+## second one binds nothing.
+const LSP_SETTING: String = "network/language_server/remote_port"
+const DAP_SETTING: String = "network/debug_adapter/remote_port"
+const DEBUGGER_SETTING: String = "network/debug/remote_port"
+## What a server that opened this editor put in the environment, matching the ports it named on
+## the command line. Kept in step with `editorArguments` in src/launch.ts.
+const LSP_ASKED: String = "GDHARNESS_LSP_PORT"
+const DAP_ASKED: String = "GDHARNESS_DAP_PORT"
+
 ## How long one attempt is given before the address is called a bad one.
 ##
 ## A socket pointed at a port nothing holds gives up by itself, in thirty seconds on Windows. One
@@ -62,6 +73,7 @@ var _connecting_for: float = 0.0
 func _ready() -> void:
 	_project_path = ProjectSettings.globalize_path("res://")
 	version_at_load = _loaded_version()
+	_keep_the_ports_this_editor_was_given()
 
 	_reconnect_timer = Timer.new()
 	_reconnect_timer.one_shot = true
@@ -243,18 +255,73 @@ func _handle_connect() -> void:
 	# somebody restarts it, and nothing else can tell the two apart.
 	# The process id with it, because a restarted editor is a different process from the one
 	# whoever started it is holding, and nothing else says which one is now on the other end.
+	# The three ports with that, because a server that assumes the defaults talks to whichever
+	# editor took them, which on a machine running two is not this one.
 	_send_message(
 		{
 			"type": "godot_ready",
 			"project_path": _project_path,
 			"addon_version": version_at_load,
-			"editor_pid": OS.get_process_id()
+			"editor_pid": OS.get_process_id(),
+			"lsp_port": _serves(LSP_ASKED, LSP_SETTING),
+			"dap_port": _serves(DAP_ASKED, DAP_SETTING),
+			"debug_port": _serving(DEBUGGER_SETTING)
 		}
 	)
 
 	connected.emit()
 
 
+## Writes the ports this editor was started on into the settings it reads them from.
+##
+## The command line moved the language server and the debug adapter for this run and the engine
+## keeps that override to itself: the setting still reads whatever it read before, so an editor
+## that restarts itself comes back on the old number and lands on top of whichever editor holds
+## it. Writing it here is what makes the move survive a restart, and what leaves one place either
+## side has to read.
+func _keep_the_ports_this_editor_was_given() -> void:
+	if not Engine.is_editor_hint():
+		return
+	_keep_port(LSP_ASKED, LSP_SETTING)
+	_keep_port(DAP_ASKED, DAP_SETTING)
+
+
+func _keep_port(variable: String, setting: String) -> void:
+	var port: int = _asked_for(variable)
+	if port < 1 or port == _serving(setting):
+		return
+	var settings: EditorSettings = EditorInterface.get_editor_settings()
+	if settings != null:
+		settings.set_setting(setting, port)
+
+
+## What this editor serves: what it was told to when a server opened it, and what its settings
+## say otherwise. The first is the one that counts, because the settings are the thing the command
+## line was overriding.
+func _serves(variable: String, setting: String) -> int:
+	var asked: int = _asked_for(variable)
+	return asked if asked > 0 else _serving(setting)
+
+
+## The port this variable names, or 0 for anything that is not one.
+static func _asked_for(variable: String) -> int:
+	var said: String = OS.get_environment(variable)
+	if not said.is_valid_int():
+		return 0
+	var port: int = int(said)
+	return port if port >= 1 and port <= 65535 else 0
+
+
+## What the settings say this editor serves on, or 0 when there is nothing to ask.
+func _serving(setting: String) -> int:
+	if not Engine.is_editor_hint():
+		return 0
+	var settings: EditorSettings = EditorInterface.get_editor_settings()
+	if settings == null or not settings.has_setting(setting):
+		return 0
+	return int(settings.get_setting(setting))
+
+
 ## The version marker beside this addon, or "" when the copy was not installed by gdharness.
 ##
 ## Read once, when this copy loads, and never again: an upgrade replaces the files under a

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

@@ -10,6 +10,10 @@ extends Node
 
 ## What the display server calls itself when the engine was started with no display at all.
 const HEADLESS_DISPLAY: String = "headless"
+## Where Godot keeps the port its own debugger listens on for a game it is playing. One setting
+## for every editor on the machine, and bound only while a game runs.
+const DEBUGGER_SETTING: String = "network/debug/remote_port"
+const LOOPBACK: String = "127.0.0.1"
 
 var _editor_plugin: EditorPlugin = null
 
@@ -24,6 +28,8 @@ func play_scene(args: Dictionary) -> Dictionary:
 	if EditorInterface.is_playing_scene():
 		EditorInterface.stop_playing_scene()
 
+	var debugger: int = _a_port_for_the_debugger()
+
 	if scene_path.is_empty():
 		EditorInterface.play_main_scene()
 	else:
@@ -35,10 +41,43 @@ func play_scene(args: Dictionary) -> Dictionary:
 	return {
 		"ok": true,
 		"playing": EditorInterface.is_playing_scene(),
-		"scenePath": EditorInterface.get_playing_scene()
+		"scenePath": EditorInterface.get_playing_scene(),
+		"debugPort": debugger
 	}
 
 
+## Gives this editor's debugger a port of its own, and answers the one the game will be sent to.
+##
+## The editor binds this while a game runs, out of a setting shared by every editor on the
+## machine, and Godot takes --lsp-port and --dap-port on its command line but nothing at all for
+## this one. So two editors playing at once want the same number, and both ways that can go are
+## wrong: a bind that fails leaves a game with no debugger behind it, which is every debug tool
+## and the whole console gone, and a bind that succeeds anyway leaves two editors on one port with
+## the games going to whichever one the operating system picks.
+##
+## Asked of the operating system each time rather than tested first, which is how the runtime
+## addon takes its own port: a port that was free a moment ago is not a port that is still free,
+## and nothing this can ask distinguishes the editor's own debugger from another editor's.
+func _a_port_for_the_debugger() -> int:
+	var settings: EditorSettings = EditorInterface.get_editor_settings()
+	if settings == null or not settings.has_setting(DEBUGGER_SETTING):
+		return 0
+	var spare: int = _any_free_port()
+	if spare > 0:
+		settings.set_setting(DEBUGGER_SETTING, spare)
+	return spare
+
+
+## A port the operating system handed out, or 0 when it would not give one.
+static func _any_free_port() -> int:
+	var probe: TCPServer = TCPServer.new()
+	if probe.listen(0, LOOPBACK) != OK:
+		return 0
+	var port: int = probe.get_local_port()
+	probe.stop()
+	return port
+
+
 func stop_playing(_args: Dictionary) -> Dictionary:
 	var was_playing: bool = EditorInterface.is_playing_scene()
 	if was_playing:
@@ -88,6 +127,17 @@ func restart_editor(_args: Dictionary) -> Dictionary:
 
 func playing_status(_args: Dictionary) -> Dictionary:
 	var playing: bool = EditorInterface.is_playing_scene()
+	# The debugger's port with it, read now rather than remembered: it is taken again before every
+	# play, so the one from when this editor greeted the server is a number it has moved off.
+	var settings: EditorSettings = EditorInterface.get_editor_settings()
+	var debugger: int = (
+		int(settings.get_setting(DEBUGGER_SETTING))
+		if settings != null and settings.has_setting(DEBUGGER_SETTING)
+		else 0
+	)
 	return {
-		"ok": true, "playing": playing, "scenePath": EditorInterface.get_playing_scene() if playing else ""
+		"ok": true,
+		"playing": playing,
+		"scenePath": EditorInterface.get_playing_scene() if playing else "",
+		"debugPort": debugger
 	}

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

@@ -70,6 +70,7 @@ func _init() -> void:
 		"inject_mouse_click": _input.inject_mouse_click,
 		"inject_mouse_motion": _input.inject_mouse_motion,
 		"click": _input.click,
+		"choose": _input.choose,
 		"wait_frames": _waits.wait_frames,
 		"wait_signal": _waits.wait_signal,
 		"wait_until": _waits.wait_until,

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

@@ -400,6 +400,158 @@ func _no_window_note(viewport: Viewport) -> String:
 	return ". This game has no window: run it with a window to reach this control"
 
 
+## Chooses an item out of a menu, by what it says or by where it is in the list.
+##
+## A menu's items are drawn rather than built, so there is no node under the pointer to aim at and
+## no rectangle to ask for: [PopupMenu] exposes their text, their ids and which one has the focus,
+## and nothing about where any of them is. So a click cannot reach one, and a whole click on the
+## [OptionButton] in front of it opens the menu on the press and closes it again on the release.
+## Every language picker, every filter and every dropdown in a game was unreachable, and the way
+## past it was to call `select` and emit `item_selected`, which sets a number and runs none of the
+## engine's own path.
+##
+## Chosen the way a keyboard chooses: the item takes the focus and then Enter presses it, which is
+## the same route through [PopupMenu] a pointer takes and which needs no geometry, so it works in a
+## game with no window as well.
+##
+## [param path] may be the menu or the button in front of it. Naming the button is what a caller
+## has, since the menu is an internal child with a generated name that changes between runs.
+func choose(params: Dictionary) -> Dictionary:
+	var node_path: String = str(params.get("path", ""))
+	if node_path.is_empty():
+		return {"type": "error", "message": "Node path required"}
+	var node: Node = _host.get_tree().root.get_node_or_null(node_path)
+	if node == null:
+		return {"type": "error", "message": "Node not found: " + node_path}
+
+	var menu: PopupMenu = _menu_of(node)
+	if menu == null:
+		return {
+			"type": "error",
+			"message":
+			(
+				"%s is a %s, which is neither a PopupMenu nor something holding one"
+				% [node_path, node.get_class()]
+			)
+		}
+
+	if not params.has("index") and str(params.get("text", "")).is_empty():
+		return {
+			"type": "error",
+			"message":
+			(
+				"%s needs the item named, by text or index. It holds: %s"
+				% [node_path, ", ".join(_items_of(menu))]
+			)
+		}
+
+	var index: int = _wanted_item(menu, params)
+	if index < 0:
+		return {
+			"type": "error",
+			"message": "%s has no such item. It holds: %s" % [node_path, ", ".join(_items_of(menu))]
+		}
+	if menu.is_item_separator(index):
+		return {"type": "error", "message": "%s item %d is a separator, not a choice" % [node_path, index]}
+	if menu.is_item_disabled(index):
+		return {
+			"type": "error",
+			"message": "%s item %d, %s, is disabled" % [node_path, index, menu.get_item_text(index)]
+		}
+
+	# Shown first, because a menu nobody has opened has no focus to move and Enter would go to
+	# whatever is behind it. An OptionButton opens its own; a bare PopupMenu is popped where it
+	# already sits, which leaves a menu that was already open where it is.
+	var opened: bool = _open_the_menu(node, menu)
+	await _host.get_tree().process_frame
+
+	menu.scroll_to_item(index)
+	menu.set_focused_item(index)
+	# Through Input rather than pushed at the menu, which is how a keyboard reaches an open one: a
+	# popup is a Window, it takes the focus when it opens, and Input delivers to whichever window
+	# has it. Pushed straight at the menu the event arrived and nothing happened.
+	Input.parse_input_event(_accept(true))
+	await _host.get_tree().process_frame
+	Input.parse_input_event(_accept(false))
+	await _host.get_tree().process_frame
+
+	var answer: Dictionary = {
+		"type": "chosen",
+		"path": node_path,
+		"index": index,
+		"text": menu.get_item_text(index),
+		"id": menu.get_item_id(index),
+		"opened": opened,
+		"menu": str(menu.get_path()),
+	}
+	# What the button in front of the menu reads now, which is the answer to "did it take": a menu
+	# item that fired changes the thing holding it, and nothing else about the press says so.
+	var chooser: OptionButton = node as OptionButton
+	if chooser != null:
+		answer["selected"] = chooser.get_selected()
+		answer["shows"] = chooser.text
+	return answer
+
+
+## The menu [param node] is, or the one it holds. An [OptionButton] and a [MenuButton] both keep
+## theirs as an internal child, which is a node a caller cannot name and should not have to.
+static func _menu_of(node: Node) -> PopupMenu:
+	var menu: PopupMenu = node as PopupMenu
+	if menu != null:
+		return menu
+	if node.has_method("get_popup"):
+		var held: Variant = node.call("get_popup")
+		if held is PopupMenu:
+			return held
+	return null
+
+
+## Which item was asked for: `text`, matched exactly and then case-insensitively, or `index`.
+## Minus one when neither names one that is there.
+static func _wanted_item(menu: PopupMenu, params: Dictionary) -> int:
+	if params.has("index"):
+		var asked: int = int(params.get("index", -1))
+		return asked if asked >= 0 and asked < menu.get_item_count() else -1
+	var wanted: String = str(params.get("text", ""))
+	if wanted.is_empty():
+		return -1
+	for index: int in menu.get_item_count():
+		if menu.get_item_text(index) == wanted:
+			return index
+	for index: int in menu.get_item_count():
+		if menu.get_item_text(index).nocasecmp_to(wanted) == 0:
+			return index
+	return -1
+
+
+## What the menu says, for a refusal that names the choices rather than the miss.
+static func _items_of(menu: PopupMenu) -> PackedStringArray:
+	var said: PackedStringArray = PackedStringArray()
+	for index: int in menu.get_item_count():
+		said.append("%d: %s" % [index, menu.get_item_text(index)])
+	return said
+
+
+## Opens the menu if it is not already, and answers whether anything opened.
+static func _open_the_menu(node: Node, menu: PopupMenu) -> bool:
+	if menu.visible:
+		return false
+	if node.has_method("show_popup"):
+		node.call("show_popup")
+		return true
+	menu.popup()
+	return true
+
+
+func _accept(pressed: bool) -> InputEventKey:
+	var event: InputEventKey = InputEventKey.new()
+	event.keycode = KEY_ENTER
+	event.physical_keycode = KEY_ENTER
+	event.key_label = KEY_ENTER
+	event.pressed = pressed
+	return event
+
+
 ## A whole click aimed at where a 3D node is drawn, for a game that picks with a ray out of the
 ## cursor rather than with a Control.
 ##

package/build/index.js

@@ -24861,10 +24861,11 @@ class FrameReader {
 }
 
 // src/ports.ts
-function portFromEnv(variable, fallback) {
+import { createServer } from "node:net";
+function portFromEnvOrNull(variable) {
   const raw = process.env[variable]?.trim();
   if (!raw) {
-    return fallback;
+    return null;
   }
   const parsed = Number.parseInt(raw, 10);
   if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65535 || String(parsed) !== raw) {
@@ -24872,6 +24873,36 @@ function portFromEnv(variable, fallback) {
   }
   return parsed;
 }
+function portFromEnv(variable, fallback) {
+  return portFromEnvOrNull(variable) ?? fallback;
+}
+async function freePort(preferred, host = "127.0.0.1") {
+  const asked = await bindable(preferred, host);
+  if (asked !== null) {
+    return asked;
+  }
+  const spare = await bindable(0, host);
+  if (spare === null) {
+    throw new Refusal(`No port could be bound on ${host}.`);
+  }
+  return spare;
+}
+function bindable(port, host) {
+  return new Promise((resolve) => {
+    const probe = createServer();
+    probe.once("error", () => {
+      resolve(null);
+    });
+    probe.once("listening", () => {
+      const bound = probe.address();
+      const taken = typeof bound === "object" && bound !== null ? bound.port : port;
+      probe.close(() => {
+        resolve(taken);
+      });
+    });
+    probe.listen(port, host);
+  });
+}
 
 // src/dap_client.ts
 var DEFAULT_DAP_PORT = 6006;
@@ -25476,6 +25507,9 @@ function resolveDefaultBridgeHost() {
   const host = process.env["GDHARNESS_BRIDGE_HOST"]?.trim();
   return host === undefined || host === "" ? DEFAULT_HOST : host;
 }
+function servedPort(said) {
+  return typeof said === "number" && Number.isInteger(said) && said > 0 && said <= 65535 ? said : undefined;
+}
 
 class GodotBridge extends EventEmitter {
   httpServer = null;
@@ -25608,6 +25642,9 @@ class GodotBridge extends EventEmitter {
       lastPongAt: this.connectionInfo?.lastPongAt,
       addonVersion: this.connectionInfo?.addonVersion,
       editorPid: this.connectionInfo?.editorPid,
+      lspPort: this.connectionInfo?.lspPort,
+      dapPort: this.connectionInfo?.dapPort,
+      debugPort: this.connectionInfo?.debugPort,
       pendingRequests: this.pendingRequests.size,
       queuedResources: this.resourceQueues.size
     };
@@ -25741,6 +25778,9 @@ class GodotBridge extends EventEmitter {
           this.connectionInfo.projectPath = message.project_path;
           this.connectionInfo.addonVersion = message.addon_version ?? "";
           this.connectionInfo.editorPid = message.editor_pid;
+          this.connectionInfo.lspPort = servedPort(message.lsp_port);
+          this.connectionInfo.dapPort = servedPort(message.dap_port);
+          this.connectionInfo.debugPort = servedPort(message.debug_port);
           this.log("info", `Godot ready: ${message.project_path}`);
           this.emitBridgeEvent("godot_connected", { projectPath: message.project_path });
         }
@@ -26013,8 +26053,8 @@ function runArguments(options) {
   }
   return args;
 }
-function editorArguments(projectPath) {
-  return ["-e", "--path", projectPath];
+function editorArguments(projectPath, ports) {
+  return ["-e", "--path", projectPath, "--lsp-port", String(ports.lsp), "--dap-port", String(ports.dap)];
 }
 function userDataIn(home, variables = process.env) {
   const moved = ["APPDATA", "XDG_DATA_HOME"];
@@ -26911,10 +26951,10 @@ function asToolResponse(payload) {
     ]
   };
 }
-function normalizeLSPError(error) {
+function normalizeLSPError(error, port) {
   if (error instanceof Error) {
     if (error.message.includes("ECONNREFUSED") || error.message.includes("Failed to connect to Godot LSP") || error.message.includes("socket closed")) {
-      return `Godot LSP is unavailable on port ${portFromEnv("GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT)}. Start the Godot editor and enable Language Server in Editor Settings, or set GDHARNESS_LSP_PORT to the port it serves.`;
+      return `Godot LSP is unavailable on port ${port}. Start the Godot editor and enable Language Server in Editor Settings, or set GDHARNESS_LSP_PORT to the port it serves.`;
     }
     return error.message;
   }
@@ -26992,7 +27032,7 @@ async function handleLSPTool(client, toolName, args) {
     }
   } catch (error) {
     return asToolResponse({
-      error: normalizeLSPError(error)
+      error: normalizeLSPError(error, client.port)
     });
   }
 }
@@ -28348,12 +28388,12 @@ var TOOL_SPECS = [
   },
   {
     name: "runtime_input",
-    description: "Input to the running game: a whole click on a Control or a 3D node 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.",
+    description: "Input to the running game: a whole click on a Control or a 3D node named by path, an item chosen out of a menu, 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, or the 3D node to click, where it is drawn."
+        description: "click: the Control to click, at its centre, or the 3D node to click, where it is drawn. choose: the PopupMenu, or the OptionButton or MenuButton in front of one."
       },
       action: { type: "string", description: "action: the InputMap action name." },
       pressed: { type: "boolean", description: "Press or release. Default true." },
@@ -28361,7 +28401,11 @@ var TOOL_SPECS = [
       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."
+        description: "text: what to type. A newline is Enter and a tab is Tab. choose: the item to take, by what it says."
+      },
+      index: {
+        type: "number",
+        description: "choose: the item to take, by where it is in the list, when text will not do."
       },
       shift: { type: "boolean" },
       ctrl: { type: "boolean" },
@@ -28383,6 +28427,10 @@ var TOOL_SPECS = [
         summary: "press and release on a Control, a frame apart, and answer with what was under the pointer and what became of the control: in_tree, removed or freed. A control out of sight inside a ScrollContainer is scrolled to first, and scrolled_into_view says whether the view moved. A 3D node is clicked where it is drawn, and landed then says the interface did not swallow the press",
         requires: ["nodePath"]
       },
+      choose: {
+        summary: "take an item out of a menu, by what it says or by where it is in the list. A menu's items are drawn rather than built, so there is nothing to click: the item takes the focus and Enter presses it, which is the engine's own path and needs no window. Answers with what was chosen and what the button in front of it shows now",
+        requires: ["nodePath"]
+      },
       action: { summary: "press or release an action", requires: ["action"] },
       key: { summary: "press or release a key", requires: ["keycode"] },
       text: {
@@ -29080,12 +29128,23 @@ class GodotServer {
       case "runtime_capture":
         return await this.handleRuntimeCommand(op === "screenshot" ? "capture_screenshot" : "capture_viewport", args);
       case "runtime_input":
-        return op === "click" ? await this.handleRuntimeCommand("click", {
-          projectPath: args["projectPath"],
-          path: readNonEmptyString(args, "nodePath") ?? "",
-          button: readString(args, "button") ?? "left",
-          double: readBoolean(args, "doubleClick") ?? false
-        }) : await this.handleRuntimeCommand(`inject_${op}`, args);
+        if (op === "click") {
+          return await this.handleRuntimeCommand("click", {
+            projectPath: args["projectPath"],
+            path: readNonEmptyString(args, "nodePath") ?? "",
+            button: readString(args, "button") ?? "left",
+            double: readBoolean(args, "doubleClick") ?? false
+          });
+        }
+        if (op === "choose") {
+          return await this.handleRuntimeCommand("choose", {
+            projectPath: args["projectPath"],
+            path: readNonEmptyString(args, "nodePath") ?? "",
+            text: readString(args, "text") ?? "",
+            ...args["index"] === undefined ? {} : { index: args["index"] }
+          });
+        }
+        return await this.handleRuntimeCommand(`inject_${op}`, args);
       case "runtime_wait":
         return await this.handleRuntimeWait(op, args);
       case "debug_breakpoint": {
@@ -29166,7 +29225,7 @@ class GodotServer {
       return {
         ok: false,
         response: this.createErrorResponse(`The editor is playing the game but its debug adapter did not answer: ${errorMessage(error)}`, [
-          "Godot serves the debug adapter on 6006 unless --dap-port says otherwise",
+          `This asked on port ${this.dap().port}, which is where the connected editor says it serves`,
           "GDHARNESS_DAP_PORT points this server at another one"
         ])
       };
@@ -29533,7 +29592,8 @@ class GodotServer {
     if (payload["error"] !== undefined) {
       const reason = payload["error"];
       return this.createErrorResponse(`Diagnostics unavailable: ${typeof reason === "string" ? reason : JSON.stringify(reason)}`, [
-        "Ensure the Godot editor is running with its language server enabled, on port 6005 or on the port GDHARNESS_LSP_PORT names"
+        `Ensure the Godot editor is running with its language server enabled, on port ${this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT)}`,
+        "GDHARNESS_LSP_PORT points this server at another one"
       ]);
     }
     const diagnostics = readArray(payload, "diagnostics") ?? [];
@@ -29550,16 +29610,33 @@ class GodotServer {
     });
   }
   async handleLSP(toolName, args) {
-    this.lspClient ??= new GodotLSPClient;
+    const port = this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT);
+    if (this.lspClient !== null && this.lspClient.port !== port) {
+      await this.lspClient.disconnect();
+      this.lspClient = null;
+    }
+    this.lspClient ??= new GodotLSPClient(port);
     return handleLSPTool(this.lspClient, toolName, args);
   }
   async handleDAP(toolName, args) {
     return handleDAPTool(this.dap(), toolName, args);
   }
   dap() {
-    this.dapClient ??= new GodotDAPClient;
+    const port = this.editorServes("dapPort", "GDHARNESS_DAP_PORT", DEFAULT_DAP_PORT);
+    if (this.dapClient !== null && this.dapClient.port !== port) {
+      this.dapClient = null;
+    }
+    this.dapClient ??= new GodotDAPClient(port);
     return this.dapClient;
   }
+  editorServes(field, variable, fallback) {
+    const named = portFromEnvOrNull(variable);
+    if (named !== null) {
+      return named;
+    }
+    const status = this.godotBridge.getStatus();
+    return (status.connected ? status[field] : undefined) ?? fallback;
+  }
   getEditorStatusPayload() {
     const status = this.godotBridge.getStatus();
     const isPortConflict = this.bridgeStartupError?.includes("EADDRINUSE") ?? false;
@@ -29587,7 +29664,8 @@ class GodotServer {
       const answer = await this.godotBridge.invokeTool("playing_status", {});
       return {
         playing: readBoolean(asParams(answer), "playing") ?? false,
-        scene: readString(asParams(answer), "scenePath") ?? ""
+        scene: readString(asParams(answer), "scenePath") ?? "",
+        debugPort: readNumber(asParams(answer), "debugPort")
       };
     } catch {
       return null;
@@ -29605,15 +29683,19 @@ class GodotServer {
         problem: reply.ok ? null : reply.message
       };
     }));
+    const playing = await this.editorPlayingState();
     return this.jsonTextResponse({
-      editor: this.getEditorStatusPayload(),
+      editor: {
+        ...this.getEditorStatusPayload(),
+        debugPort: playing?.debugPort ?? this.godotBridge.getStatus().debugPort
+      },
       godot: {
         path: godotPath,
         version: godotPath === null ? null : await this.godotVersion(godotPath)
       },
       game: {
         processActive: this.activeProcess !== null,
-        playingInEditor: await this.editorPlayingState(),
+        playingInEditor: playing,
         runtimeConnected: games.some((game) => game.reachable),
         runtimes: games
       }
@@ -29672,10 +29754,10 @@ class GodotServer {
       return project.response;
     }
     if (this.godotBridge.isConnected()) {
-      return this.createErrorResponse("An editor is already connected to this server, and a second one would take the language server and debug adapter ports from it.", [
+      return this.createErrorResponse("An editor is already connected to this server.", [
         "editor_status says which editor is answering, and for which project",
         "editor_launch restart replaces the connected editor rather than joining it",
-        "Close the open editor first if the new project is the one you want"
+        "Another project wants its own gdharness server, which is its own harness session"
       ]);
     }
     const engine = await this.engine();
@@ -29683,10 +29765,16 @@ class GodotServer {
       return engine.response;
     }
     this.logDebug(`Launching Godot editor for project: ${project.value.path}`);
-    const editor = spawn(engine.value, editorArguments(project.value.path), {
+    const ports = await this.portsForAnEditor();
+    const editor = spawn(engine.value, editorArguments(project.value.path, ports), {
       stdio: "ignore",
       detached: true,
-      env: { ...process.env, GDHARNESS_RUNTIME_DIR: runtimeDirectory() }
+      env: {
+        ...process.env,
+        GDHARNESS_RUNTIME_DIR: runtimeDirectory(),
+        GDHARNESS_LSP_PORT: String(ports.lsp),
+        GDHARNESS_DAP_PORT: String(ports.dap)
+      }
     });
     const started = await new Promise((resolve) => {
       editor.once("spawn", () => {
@@ -29703,9 +29791,16 @@ class GodotServer {
     return this.jsonTextResponse({
       launched: true,
       pid: editor.pid ?? null,
-      projectPath: project.value.path
+      projectPath: project.value.path,
+      lspPort: ports.lsp,
+      dapPort: ports.dap
     });
   }
+  async portsForAnEditor() {
+    const lsp = portFromEnvOrNull("GDHARNESS_LSP_PORT") ?? await freePort(DEFAULT_LSP_PORT);
+    const dap = portFromEnvOrNull("GDHARNESS_DAP_PORT") ?? await freePort(DEFAULT_DAP_PORT);
+    return { lsp, dap };
+  }
   async handleRunProject(args, op) {
     const project = this.project(args);
     if (!project.ok) {
@@ -29773,7 +29868,7 @@ class GodotServer {
       await this.dap().connect();
     } catch (error) {
       return this.createErrorResponse(`The editor is connected but its debug adapter is not: ${errorMessage(error)}`, [
-        "Godot serves the debug adapter on 6006 unless --dap-port says otherwise",
+        `This asked on port ${this.dap().port}, which is where the connected editor says it serves`,
         "GDHARNESS_DAP_PORT points this server at another one"
       ]);
     }
@@ -29795,6 +29890,7 @@ class GodotServer {
       through: "editor",
       scene: scene === null ? "the main scene" : `res://${scene}`,
       refreshedClasses,
+      debugPort: readNumber(asParams(JSON.parse(answer.content[0]?.text ?? "{}")), "debugPort"),
       message: "The editor is playing it, so its debugger holds it: the debug_* tools can reach it, " + "editor_output reads its console through the debug adapter, and editor_run stop ends it."
     });
   }
@@ -29977,7 +30073,7 @@ class GodotServer {
   async handleRuntimeCommand(command, args, timeoutMs = this.runtimeTimeoutMs()) {
     const { op: _op, projectPath, ...params } = asParams(args);
     const announced = runtimesAnnounced();
-    const choice = chooseRuntime(announced.running, typeof projectPath === "string" ? projectPath : undefined, announced.unspoken);
+    const choice = chooseRuntime(announced.running, typeof projectPath === "string" ? projectPath : this.ownProject ?? undefined, announced.unspoken);
     if ("problem" in choice) {
       return this.createErrorResponse(choice.problem);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "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",