gdharness 0.9.2 → 0.9.4

package/build/cli.js

@@ -173,6 +173,7 @@ function userDataIn(home, variables = process.env) {
   }
   return carried;
 }
+var OPENED_BY_A_SERVER = "GDHARNESS_OPENED_BY_A_SERVER";
 
 // node_modules/yaml/dist/nodes/identity.js
 var require_identity = __commonJS(function(exports) {
@@ -15667,7 +15668,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_run",
-      description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until stop, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way.",
+      description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way.",
       parameters: {
         projectPath: PROJECT_PATH,
         scene: { type: "string", description: "A scene to run instead of the main scene." },
@@ -15680,7 +15681,7 @@ var init_tool_definitions = __esm(() => {
       },
       requires: ["projectPath"],
       operations: {
-        start: { summary: "run the project until stop", requires: [] },
+        start: { summary: "run the project until it quits or is stopped", requires: [] },
         stop: { summary: "end the run and answer with what it printed last", requires: [] },
         check: { summary: "boot headless, quit after a few frames, and report the verdict", requires: [] }
       },
@@ -15688,7 +15689,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_output",
-      description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. Answers with the counts and the verdict as well as the entries.",
+      description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. Answers with the counts and the verdict as well as the entries. A run that has quit still answers here, with running false and its exit code, until the next one starts.",
       parameters: {
         severity: {
           type: "string",
@@ -34499,6 +34500,7 @@ var init_godot_bridge = __esm(() => {
         lspPort: this.connectionInfo?.lspPort,
         dapPort: this.connectionInfo?.dapPort,
         debugPort: this.connectionInfo?.debugPort,
+        openedByAServer: this.connectionInfo?.openedByAServer,
         pendingRequests: this.pendingRequests.size,
         queuedResources: this.resourceQueues.size
       };
@@ -34639,6 +34641,7 @@ var init_godot_bridge = __esm(() => {
             this.connectionInfo.lspPort = servedPort(message.lsp_port);
             this.connectionInfo.dapPort = servedPort(message.dap_port);
             this.connectionInfo.debugPort = servedPort(message.debug_port);
+            this.connectionInfo.openedByAServer = message.opened_by_a_server === true;
             this.log("info", `Godot ready: ${message.project_path}`);
             this.emitBridgeEvent("godot_connected", { projectPath: message.project_path });
           }
@@ -35999,6 +36002,17 @@ import { promisify as promisify5 } from "node:util";
 function patienceForFrames(frames, atLeast) {
   return Math.max(atLeast, frames / SLOWEST_FRAME_RATE * 1000 + atLeast);
 }
+function alive(pid) {
+  if (pid === undefined) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function isOfType(value, kind) {
   switch (kind) {
     case "string":
@@ -36234,12 +36248,7 @@ class GodotServer {
     if (announced === null || announced.pid === process.pid) {
       return null;
     }
-    try {
-      process.kill(announced.pid, 0);
-      return announced.pid;
-    } catch {
-      return null;
-    }
+    return alive(announced.pid) ? announced.pid : null;
   }
   stopWatchingForASuccessor() {
     if (this.successorWatch !== null) {
@@ -36699,6 +36708,15 @@ class GodotServer {
   }
   async debuggedGame() {
     const game = this.activeProcess;
+    if (game !== null && game.exitCode !== null) {
+      return {
+        ok: false,
+        response: this.createErrorResponse(`The last run has already finished (exit code ${game.exitCode}), so there is no debug session to answer for.`, [
+          "editor_output still reads what it printed, until the next run starts",
+          "editor_run start plays another, which the debugger can hold"
+        ])
+      };
+    }
     if (game === null) {
       return {
         ok: false,
@@ -37191,7 +37209,7 @@ class GodotServer {
         version: godotPath === null ? null : await this.godotVersion(godotPath)
       },
       game: {
-        processActive: this.activeProcess !== null,
+        processActive: this.activeProcess?.exitCode === null,
         playingInEditor: playing,
         runtimeConnected: games.some((game) => game.reachable),
         runtimes: games
@@ -37206,7 +37224,8 @@ class GodotServer {
         "editor_status says whether the bridge is up and what has reached it"
       ]);
     }
-    const asked = await this.handleViaBridge("restart_editor", {});
+    const mine = before.openedByAServer === true && before.projectPath !== undefined;
+    const asked = mine ? await this.startItAgain(before.projectPath ?? "", before.editorPid) : await this.handleViaBridge("restart_editor", {});
     if (asked.isError === true) {
       return asked;
     }
@@ -37234,6 +37253,26 @@ class GodotServer {
       tookMs: Date.now() - began
     });
   }
+  async startItAgain(projectPath, editorPid) {
+    const engine = await this.engine();
+    if (!engine.ok) {
+      return engine.response;
+    }
+    const ports = {
+      lsp: this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT),
+      dap: this.editorServes("dapPort", "GDHARNESS_DAP_PORT", DEFAULT_DAP_PORT)
+    };
+    const asked = await this.handleViaBridge("quit_editor", {});
+    if (asked.isError === true) {
+      return asked;
+    }
+    await this.waitForBridge(() => !alive(editorPid), Date.now() + EDITOR_RESTART_TIMEOUT_MS);
+    const opened = await this.openAnEditor(engine.value, projectPath, ports);
+    if (opened.error !== null) {
+      return this.createErrorResponse(`The editor was asked to go and could not be started again: ${opened.error}`, [`editor_launch opens one on ${projectPath}`]);
+    }
+    return this.jsonTextResponse({ restarting: true, pid: opened.pid });
+  }
   async waitForBridge(reached, deadline) {
     for (;; ) {
       if (reached()) {
@@ -37263,14 +37302,28 @@ class GodotServer {
     }
     this.logDebug(`Launching Godot editor for project: ${project.value.path}`);
     const ports = await this.portsForAnEditor();
-    const editor = spawn(engine.value, editorArguments(project.value.path, ports), {
+    const opened = await this.openAnEditor(engine.value, project.value.path, ports);
+    if (opened.error !== null) {
+      return this.createErrorResponse(`Could not start the editor: ${opened.error}`);
+    }
+    return this.jsonTextResponse({
+      launched: true,
+      pid: opened.pid,
+      projectPath: project.value.path,
+      lspPort: ports.lsp,
+      dapPort: ports.dap
+    });
+  }
+  async openAnEditor(engine, projectPath, ports) {
+    const editor = spawn(engine, editorArguments(projectPath, ports), {
       stdio: "ignore",
       detached: true,
       env: {
         ...process.env,
         GDHARNESS_RUNTIME_DIR: runtimeDirectory(),
         GDHARNESS_LSP_PORT: String(ports.lsp),
-        GDHARNESS_DAP_PORT: String(ports.dap)
+        GDHARNESS_DAP_PORT: String(ports.dap),
+        [OPENED_BY_A_SERVER]: "1"
       }
     });
     const started = await new Promise((resolve) => {
@@ -37282,16 +37335,10 @@ class GodotServer {
       });
     });
     if (started !== null) {
-      return this.createErrorResponse(`Could not start the editor: ${started}`);
+      return { pid: null, error: started };
     }
     editor.unref();
-    return this.jsonTextResponse({
-      launched: true,
-      pid: editor.pid ?? null,
-      projectPath: project.value.path,
-      lspPort: ports.lsp,
-      dapPort: ports.dap
-    });
+    return { pid: editor.pid ?? null, error: null };
   }
   async portsForAnEditor() {
     const lsp = portFromEnvOrNull("GDHARNESS_LSP_PORT") ?? await freePort(DEFAULT_LSP_PORT);
@@ -37326,7 +37373,7 @@ class GodotServer {
     if (op === "check") {
       return await this.checkBoot(engine.value, project.value.path, sceneArgument, args);
     }
-    if (this.activeProcess) {
+    if (this.activeProcess?.exitCode === null) {
       this.logDebug("Ending the running game before starting another");
       await this.endActiveGame();
     }
@@ -37345,11 +37392,6 @@ class GodotServer {
     this.logDebug(`Running Godot project: ${engine.value} ${cmdArgs.join(" ")}`);
     const started = this.spawnGame(engine.value, cmdArgs);
     this.activeProcess = started;
-    started.process.on("exit", () => {
-      if (this.activeProcess === started) {
-        this.activeProcess = null;
-      }
-    });
     return this.jsonTextResponse({
       started: true,
       through: "gdharness",
@@ -38412,27 +38454,42 @@ function displayPath(harness, platform = process3.platform) {
   }
   return `${harness.scope === "home" ? "~/" : ""}${file.replaceAll("\\", "/")}`;
 }
-function entryFor(shape, launch) {
+var OURS = ["GODOT_PATH", "GDHARNESS_PROJECT"];
+function environmentFor(launch, held) {
+  const kept = {};
+  if (typeof held === "object" && held !== null && !Array.isArray(held)) {
+    for (const [name, value] of Object.entries(held)) {
+      if (typeof value === "string" && !OURS.includes(name)) {
+        kept[name] = value;
+      }
+    }
+  }
+  return { ...kept, ...launch.env };
+}
+function entryFor(shape, launch, held) {
+  const before = typeof held === "object" && held !== null && !Array.isArray(held) ? { ...held } : {};
   if (shape === "opencode") {
     return {
+      ...before,
       type: "local",
       command: [launch.command, ...launch.args],
-      environment: { ...launch.env },
+      environment: environmentFor(launch, before["environment"]),
       enabled: true
     };
   }
   return {
+    ...before,
     ...shape === "typed" ? { type: "stdio" } : {},
     command: launch.command,
     args: [...launch.args],
-    env: { ...launch.env }
+    env: environmentFor(launch, before["env"])
   };
 }
 function merged(existing, harness, launch) {
   const root = typeof existing === "object" && existing !== null && !Array.isArray(existing) ? { ...existing } : {};
   const held = root[harness.container];
   const servers = typeof held === "object" && held !== null && !Array.isArray(held) ? { ...held } : {};
-  servers[SERVER_KEY] = entryFor(harness.shape, launch);
+  servers[SERVER_KEY] = entryFor(harness.shape, launch, servers[SERVER_KEY]);
   root[harness.container] = servers;
   return root;
 }
@@ -38550,6 +38607,17 @@ function disconnect(harness, projectPath) {
 `, "utf8");
   return { harness, path, action: "removed" };
 }
+function launchedBy(entry) {
+  if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+    return;
+  }
+  const held = entry;
+  const whole = held["command"];
+  const args = Array.isArray(held["args"]) ? held["args"] : [];
+  const parts = Array.isArray(whole) ? whole : [whole, ...args];
+  const said = parts.filter((part) => typeof part === "string");
+  return said.length === 0 ? undefined : said.join(" ");
+}
 function connect(harness, projectPath, launch) {
   const path = configPath(harness, projectPath);
   if (harness.snippet !== undefined) {
@@ -38574,8 +38642,11 @@ function connect(harness, projectPath, launch) {
   }
   const container = typeof existing === "object" && existing !== null && !Array.isArray(existing) ? existing[harness.container] : undefined;
   const already = typeof container === "object" && container !== null && SERVER_KEY in container;
-  return put(harness, path, `${JSON.stringify(merged(existing, harness, launch), null, 2)}
+  const written = put(harness, path, `${JSON.stringify(merged(existing, harness, launch), null, 2)}
 `, already);
+  const was = launchedBy(container?.[SERVER_KEY]);
+  const now = launchedBy(entryFor(harness.shape, launch));
+  return was === undefined || was === now ? written : { ...written, wasLaunchedBy: was };
 }
 function put(harness, path, contents, already) {
   mkdirSync(dirname2(path), { recursive: true });
@@ -39262,6 +39333,10 @@ function reportConnection(group, launch, projectPath) {
     return;
   }
   console.log(`${who}: ${written.action} ${written.path}`);
+  if (written.wasLaunchedBy !== undefined) {
+    console.log(`  it was launched by  ${written.wasLaunchedBy}`);
+    console.log(`  now by              ${[launch.command, ...launch.args].join(" ")}`);
+  }
   for (const harness of group.harnesses) {
     if (harness.manual !== undefined) {
       console.log(`  ${harness.name}: ${harness.manual}`);

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

@@ -23,8 +23,9 @@ const MAX_RECONNECT_DELAY: float = 30.0
 const ELSEWHERE_CLOSE_CODE: int = 4001
 
 ## 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.
+## file is one for every editor of this engine version on the machine, so two open at once want the
+## same three and the second one binds nothing. Read here and never written, for the reason
+## [method _serves] gives.
 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"
@@ -32,6 +33,9 @@ const DEBUGGER_SETTING: String = "network/debug/remote_port"
 ## 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"
+## What a server that opened this editor says about itself, so that being opened by one is stated
+## rather than guessed at from the ports. Kept in step with `OPENED_BY_A_SERVER` in src/launch.ts.
+const OPENED_BY_A_SERVER: String = "GDHARNESS_OPENED_BY_A_SERVER"
 
 ## How long one attempt is given before the address is called a bad one.
 ##
@@ -81,7 +85,6 @@ 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
@@ -273,39 +276,41 @@ func _handle_connect() -> void:
 			"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)
+			"debug_port": _serving(DEBUGGER_SETTING),
+			# Whether a server started this editor, which is the only kind that can be started again
+			# as itself: the engine hands back none of the arguments it was given, so the arguments
+			# have to come from whoever wrote them. See `restart_editor` in play_tools.gd.
+			"opened_by_a_server": _opened_by_a_server()
 		}
 	)
 
 	connected.emit()
 
 
-## Writes the ports this editor was started on into the settings it reads them from.
+## Whether a gdharness server started this editor, which it says in the environment.
 ##
-## 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)
+## It decides who may restart this editor by starting it again. Only a server that wrote the
+## arguments can write them a second time, and only an editor started that way needs it: one opened
+## by hand is on the ports its own settings name and comes back on them by itself.
+##
+## Said outright rather than read off the two port variables, which a server also sets and anybody
+## else may: an editor started from a shell that exports them is one somebody opened themselves,
+## and taking it for a server's is taking an editor off somebody's desk and putting a new one there.
+static func _opened_by_a_server() -> bool:
+	return not OS.get_environment(OPENED_BY_A_SERVER).is_empty()
 
 
-## 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.
+## 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 what the command line was
+## overriding.
+##
+## The settings are read and never written. They were written for a while, because the engine keeps
+## a command-line port override to itself and hands none of it back, so an editor restarting itself
+## came up on whatever the settings said. But there is one settings file for every editor of this
+## engine version on the machine, so writing a port chosen for one project made it the number every
+## other project's editor came up on: an editor opened by hand for something else inherited it and
+## collided with the editor it was moved away from. Restarting is done by starting the editor again
+## with the same arguments now, which is `editor_launch restart`, so there is nothing to persist.
 func _serves(variable: String, setting: String) -> int:
 	var asked: int = _asked_for(variable)
 	return asked if asked > 0 else _serving(setting)

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

@@ -77,6 +77,7 @@ func _init_tools() -> void:
 		# Animation tools
 		"play_scene": [_play_tools, "play_scene"],
 		"restart_editor": [_play_tools, "restart_editor"],
+		"quit_editor": [_play_tools, "quit_editor"],
 		"stop_playing": [_play_tools, "stop_playing"],
 		"playing_status": [_play_tools, "playing_status"],
 		"create_animation": [_animation_tools, "create_animation"],

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

@@ -125,6 +125,33 @@ func restart_editor(_args: Dictionary) -> Dictionary:
 	return {"ok": true, "restarting": true, "saved": true}
 
 
+## Ends this editor, having saved, so that whoever opened it can open it again.
+##
+## The editor's half of restarting one a server started. Godot's own restart cannot carry the ports
+## such an editor was given, for the reason above: the engine consumes the arguments and hands none
+## of them back. So the server starts it again itself, and this is the part only the editor can do.
+##
+## Saved first, exactly as the restart above saves. The editor is going either way, and unsaved
+## scenes are not this tool's to lose.
+func quit_editor(_args: Dictionary) -> Dictionary:
+	if EditorInterface.is_playing_scene():
+		EditorInterface.stop_playing_scene()
+
+	EditorInterface.save_all_scenes()
+
+	# Deferred so this answer is on its way out before the editor goes.
+	_leave.call_deferred()
+
+	return {"ok": true, "quitting": true, "saved": true}
+
+
+## Asked of the tree the editor's own window is in, because this object is not in one.
+static func _leave() -> void:
+	var base: Control = EditorInterface.get_base_control()
+	if base != null and base.get_tree() != null:
+		base.get_tree().quit()
+
+
 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

package/build/index.js

@@ -25718,6 +25718,7 @@ class GodotBridge extends EventEmitter {
       lspPort: this.connectionInfo?.lspPort,
       dapPort: this.connectionInfo?.dapPort,
       debugPort: this.connectionInfo?.debugPort,
+      openedByAServer: this.connectionInfo?.openedByAServer,
       pendingRequests: this.pendingRequests.size,
       queuedResources: this.resourceQueues.size
     };
@@ -25858,6 +25859,7 @@ class GodotBridge extends EventEmitter {
           this.connectionInfo.lspPort = servedPort(message.lsp_port);
           this.connectionInfo.dapPort = servedPort(message.dap_port);
           this.connectionInfo.debugPort = servedPort(message.debug_port);
+          this.connectionInfo.openedByAServer = message.opened_by_a_server === true;
           this.log("info", `Godot ready: ${message.project_path}`);
           this.emitBridgeEvent("godot_connected", { projectPath: message.project_path });
         }
@@ -26148,6 +26150,7 @@ function runArguments(options) {
 function editorArguments(projectPath, ports) {
   return ["-e", "--path", projectPath, "--lsp-port", String(ports.lsp), "--dap-port", String(ports.dap)];
 }
+var OPENED_BY_A_SERVER = "GDHARNESS_OPENED_BY_A_SERVER";
 function userDataIn(home, variables = process.env) {
   const moved = ["APPDATA", "XDG_DATA_HOME"];
   const carried = {};
@@ -28259,7 +28262,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_run",
-    description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until stop, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way.",
+    description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way.",
     parameters: {
       projectPath: PROJECT_PATH,
       scene: { type: "string", description: "A scene to run instead of the main scene." },
@@ -28272,7 +28275,7 @@ var TOOL_SPECS = [
     },
     requires: ["projectPath"],
     operations: {
-      start: { summary: "run the project until stop", requires: [] },
+      start: { summary: "run the project until it quits or is stopped", requires: [] },
       stop: { summary: "end the run and answer with what it printed last", requires: [] },
       check: { summary: "boot headless, quit after a few frames, and report the verdict", requires: [] }
     },
@@ -28280,7 +28283,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_output",
-    description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. Answers with the counts and the verdict as well as the entries.",
+    description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. Answers with the counts and the verdict as well as the entries. A run that has quit still answers here, with running false and its exit code, until the next one starts.",
     parameters: {
       severity: {
         type: "string",
@@ -28717,6 +28720,17 @@ var SLOWEST_FRAME_RATE = 20;
 function patienceForFrames(frames, atLeast) {
   return Math.max(atLeast, frames / SLOWEST_FRAME_RATE * 1000 + atLeast);
 }
+function alive(pid) {
+  if (pid === undefined) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function isOfType(value, kind) {
   switch (kind) {
     case "string":
@@ -29014,12 +29028,7 @@ class GodotServer {
     if (announced === null || announced.pid === process.pid) {
       return null;
     }
-    try {
-      process.kill(announced.pid, 0);
-      return announced.pid;
-    } catch {
-      return null;
-    }
+    return alive(announced.pid) ? announced.pid : null;
   }
   stopWatchingForASuccessor() {
     if (this.successorWatch !== null) {
@@ -29479,6 +29488,15 @@ class GodotServer {
   }
   async debuggedGame() {
     const game = this.activeProcess;
+    if (game !== null && game.exitCode !== null) {
+      return {
+        ok: false,
+        response: this.createErrorResponse(`The last run has already finished (exit code ${game.exitCode}), so there is no debug session to answer for.`, [
+          "editor_output still reads what it printed, until the next run starts",
+          "editor_run start plays another, which the debugger can hold"
+        ])
+      };
+    }
     if (game === null) {
       return {
         ok: false,
@@ -29971,7 +29989,7 @@ class GodotServer {
         version: godotPath === null ? null : await this.godotVersion(godotPath)
       },
       game: {
-        processActive: this.activeProcess !== null,
+        processActive: this.activeProcess?.exitCode === null,
         playingInEditor: playing,
         runtimeConnected: games.some((game) => game.reachable),
         runtimes: games
@@ -29986,7 +30004,8 @@ class GodotServer {
         "editor_status says whether the bridge is up and what has reached it"
       ]);
     }
-    const asked = await this.handleViaBridge("restart_editor", {});
+    const mine = before.openedByAServer === true && before.projectPath !== undefined;
+    const asked = mine ? await this.startItAgain(before.projectPath ?? "", before.editorPid) : await this.handleViaBridge("restart_editor", {});
     if (asked.isError === true) {
       return asked;
     }
@@ -30014,6 +30033,26 @@ class GodotServer {
       tookMs: Date.now() - began
     });
   }
+  async startItAgain(projectPath, editorPid) {
+    const engine = await this.engine();
+    if (!engine.ok) {
+      return engine.response;
+    }
+    const ports = {
+      lsp: this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT),
+      dap: this.editorServes("dapPort", "GDHARNESS_DAP_PORT", DEFAULT_DAP_PORT)
+    };
+    const asked = await this.handleViaBridge("quit_editor", {});
+    if (asked.isError === true) {
+      return asked;
+    }
+    await this.waitForBridge(() => !alive(editorPid), Date.now() + EDITOR_RESTART_TIMEOUT_MS);
+    const opened = await this.openAnEditor(engine.value, projectPath, ports);
+    if (opened.error !== null) {
+      return this.createErrorResponse(`The editor was asked to go and could not be started again: ${opened.error}`, [`editor_launch opens one on ${projectPath}`]);
+    }
+    return this.jsonTextResponse({ restarting: true, pid: opened.pid });
+  }
   async waitForBridge(reached, deadline) {
     for (;; ) {
       if (reached()) {
@@ -30043,14 +30082,28 @@ class GodotServer {
     }
     this.logDebug(`Launching Godot editor for project: ${project.value.path}`);
     const ports = await this.portsForAnEditor();
-    const editor = spawn(engine.value, editorArguments(project.value.path, ports), {
+    const opened = await this.openAnEditor(engine.value, project.value.path, ports);
+    if (opened.error !== null) {
+      return this.createErrorResponse(`Could not start the editor: ${opened.error}`);
+    }
+    return this.jsonTextResponse({
+      launched: true,
+      pid: opened.pid,
+      projectPath: project.value.path,
+      lspPort: ports.lsp,
+      dapPort: ports.dap
+    });
+  }
+  async openAnEditor(engine, projectPath, ports) {
+    const editor = spawn(engine, editorArguments(projectPath, ports), {
       stdio: "ignore",
       detached: true,
       env: {
         ...process.env,
         GDHARNESS_RUNTIME_DIR: runtimeDirectory(),
         GDHARNESS_LSP_PORT: String(ports.lsp),
-        GDHARNESS_DAP_PORT: String(ports.dap)
+        GDHARNESS_DAP_PORT: String(ports.dap),
+        [OPENED_BY_A_SERVER]: "1"
       }
     });
     const started = await new Promise((resolve) => {
@@ -30062,16 +30115,10 @@ class GodotServer {
       });
     });
     if (started !== null) {
-      return this.createErrorResponse(`Could not start the editor: ${started}`);
+      return { pid: null, error: started };
     }
     editor.unref();
-    return this.jsonTextResponse({
-      launched: true,
-      pid: editor.pid ?? null,
-      projectPath: project.value.path,
-      lspPort: ports.lsp,
-      dapPort: ports.dap
-    });
+    return { pid: editor.pid ?? null, error: null };
   }
   async portsForAnEditor() {
     const lsp = portFromEnvOrNull("GDHARNESS_LSP_PORT") ?? await freePort(DEFAULT_LSP_PORT);
@@ -30106,7 +30153,7 @@ class GodotServer {
     if (op === "check") {
       return await this.checkBoot(engine.value, project.value.path, sceneArgument, args);
     }
-    if (this.activeProcess) {
+    if (this.activeProcess?.exitCode === null) {
       this.logDebug("Ending the running game before starting another");
       await this.endActiveGame();
     }
@@ -30125,11 +30172,6 @@ class GodotServer {
     this.logDebug(`Running Godot project: ${engine.value} ${cmdArgs.join(" ")}`);
     const started = this.spawnGame(engine.value, cmdArgs);
     this.activeProcess = started;
-    started.process.on("exit", () => {
-      if (this.activeProcess === started) {
-        this.activeProcess = null;
-      }
-    });
     return this.jsonTextResponse({
       started: true,
       through: "gdharness",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "0.9.2",
+  "version": "0.9.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",