gdharness 0.9.1 → 0.9.3

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) {
@@ -14711,6 +14712,9 @@ var init_types = __esm(() => {
 
 // src/paths.ts
 import { isAbsolute, relative, resolve, sep } from "node:path";
+function isSameDirectory(onePath, otherPath) {
+  return relative(resolve(onePath), resolve(otherPath)) === "";
+}
 function isWithinRoot(rootPath, candidatePath) {
   const step = relative(resolve(rootPath), resolve(candidatePath));
   return step !== ".." && !step.startsWith(`..${sep}`) && !isAbsolute(step);
@@ -15845,7 +15849,11 @@ var init_tool_definitions = __esm(() => {
           blank: true,
           description: `set: the value, fitted to the property's type. "" writes an empty string.`
         },
-        method: { type: "string", ops: ["call"] },
+        method: {
+          type: "string",
+          ops: ["call"],
+          description: 'call: which one to call. Colons call through the objects a node holds, "_game:run:advance", the same way a property is written through them.'
+        },
         args: {
           type: "array",
           ops: ["call"],
@@ -15858,7 +15866,10 @@ var init_tool_definitions = __esm(() => {
           summary: "set a property, on a node or on an object it holds",
           requires: ["property", "value"]
         },
-        call: { summary: "call a method and return its result", requires: ["method"] }
+        call: {
+          summary: "call a method, on a node or on an object it holds, and return its result",
+          requires: ["method"]
+        }
       }
     },
     {
@@ -30772,11 +30783,29 @@ var init_stdio2 = __esm(() => {
 });
 
 // src/bridge-announce.ts
-import { mkdirSync as mkdirSync5, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "node:fs";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync9, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "node:fs";
 import { dirname as dirname6, join as join11 } from "node:path";
 function announcementPath(projectPath) {
   return join11(projectPath, ".godot", "gdharness-bridge.json");
 }
+function readAnnouncement(path) {
+  try {
+    const parsed = JSON.parse(readFileSync9(path, "utf8"));
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
+    }
+    const said = parsed;
+    if (typeof said.port !== "number" || typeof said.pid !== "number") {
+      return null;
+    }
+    return said;
+  } catch {
+    return null;
+  }
+}
+function announcementIsOurs(path) {
+  return readAnnouncement(path)?.pid === process.pid;
+}
 function announceBridge(projectPath, bridge) {
   const path = announcementPath(projectPath);
   try {
@@ -30798,7 +30827,7 @@ function announceBridge(projectPath, bridge) {
   }
 }
 function withdrawBridge(path) {
-  if (path === null) {
+  if (path === null || !announcementIsOurs(path)) {
     return;
   }
   try {
@@ -34324,14 +34353,15 @@ function resolveDefaultBridgeHost() {
 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);
+function getDefaultBridge(ownProject = null) {
+  defaultBridge ??= new GodotBridge(resolveDefaultBridgePort(), resolveDefaultBridgeHost(), DEFAULT_TIMEOUT_MS, ownProject);
   return defaultBridge;
 }
-var DEFAULT_PORT = 6505, DEFAULT_HOST = "127.0.0.1", DEFAULT_TIMEOUT_MS = 30000, KEEPALIVE_INTERVAL_MS = 1e4, SECOND_CONNECTION_CLOSE_CODE = 4000, GodotBridge, defaultBridge = null;
+var DEFAULT_PORT = 6505, DEFAULT_HOST = "127.0.0.1", DEFAULT_TIMEOUT_MS = 30000, KEEPALIVE_INTERVAL_MS = 1e4, SECOND_CONNECTION_CLOSE_CODE = 4000, OTHER_PROJECT_CLOSE_CODE = 4001, GodotBridge, defaultBridge = null;
 var init_godot_bridge = __esm(() => {
   init_wrapper();
   init_errors();
+  init_paths();
   init_ports();
   GodotBridge = class GodotBridge extends EventEmitter {
     httpServer = null;
@@ -34345,13 +34375,16 @@ var init_godot_bridge = __esm(() => {
     boundPort = null;
     host;
     timeoutMs;
-    mayMove;
-    constructor(port = DEFAULT_PORT, host = DEFAULT_HOST, timeoutMs = DEFAULT_TIMEOUT_MS, mayMove = false) {
+    ownProject;
+    constructor(port = DEFAULT_PORT, host = DEFAULT_HOST, timeoutMs = DEFAULT_TIMEOUT_MS, ownProject = null) {
       super();
       this.wantedPort = port;
       this.host = host;
       this.timeoutMs = timeoutMs;
-      this.mayMove = mayMove;
+      this.ownProject = ownProject;
+    }
+    get mayMove() {
+      return this.ownProject !== null;
     }
     get port() {
       return this.boundPort ?? this.wantedPort;
@@ -34467,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
       };
@@ -34597,12 +34631,17 @@ var init_godot_bridge = __esm(() => {
         }
         case "godot_ready":
           if (this.connectionInfo) {
+            if (this.belongsElsewhere(message.project_path)) {
+              this.sendElsewhere(message.project_path);
+              return;
+            }
             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.connectionInfo.openedByAServer = message.opened_by_a_server === true;
             this.log("info", `Godot ready: ${message.project_path}`);
             this.emitBridgeEvent("godot_connected", { projectPath: message.project_path });
           }
@@ -34679,6 +34718,21 @@ var init_godot_bridge = __esm(() => {
       clearInterval(this.pingInterval);
       this.pingInterval = null;
     }
+    belongsElsewhere(theirProject) {
+      if (this.ownProject === null || theirProject.trim() === "") {
+        return false;
+      }
+      return !isSameDirectory(this.ownProject, theirProject);
+    }
+    sendElsewhere(theirProject) {
+      const said = `this server serves ${this.ownProject ?? ""}, and that editor has ${theirProject} open`;
+      this.log("warn", `Turning away an editor from another project: ${said}`);
+      const stranger = this.socket;
+      this.socket = null;
+      this.connectionInfo = null;
+      this.stopKeepalive();
+      stranger?.close(OTHER_PROJECT_CLOSE_CODE, said);
+    }
     handleDisconnect(disconnectedSocket, reason) {
       if (disconnectedSocket && this.socket && disconnectedSocket !== this.socket) {
         this.log("debug", "Ignoring stale Godot socket disconnect event");
@@ -35603,7 +35657,7 @@ var init_lsp_client = __esm(() => {
 });
 
 // src/project-scan.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync9 } from "node:fs";
+import { readdirSync as readdirSync4, readFileSync as readFileSync10 } from "node:fs";
 import { join as join12 } from "node:path";
 function projectStructure(projectPath) {
   const structure = { scenes: 0, scripts: 0, assets: 0, other: 0 };
@@ -35666,7 +35720,7 @@ function searchProject(projectPath, options) {
       }
       result.summary.files_searched += 1;
       const matches = [];
-      for (const [index, line] of readFileSync9(entryPath, "utf8").split(`
+      for (const [index, line] of readFileSync10(entryPath, "utf8").split(`
 `).entries()) {
         if (full()) {
           break;
@@ -35694,7 +35748,7 @@ var init_project_scan = __esm(() => {
 });
 
 // src/runtime-client.ts
-import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync as readFileSync10, unlinkSync } from "node:fs";
+import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync as readFileSync11, unlinkSync } from "node:fs";
 import { createConnection as createConnection3 } from "node:net";
 import { tmpdir as tmpdir4 } from "node:os";
 import { join as join13, resolve as resolve4 } from "node:path";
@@ -35725,7 +35779,7 @@ function processAlive(pid) {
 function parseAnnouncement(file, pid) {
   let fields;
   try {
-    fields = asParams(JSON.parse(readFileSync10(file, "utf8")));
+    fields = asParams(JSON.parse(readFileSync11(file, "utf8")));
   } catch {
     return { kind: "rubbish" };
   }
@@ -35918,14 +35972,14 @@ var init_runtime_client = __esm(() => {
 });
 
 // src/setup.ts
-import { cpSync as cpSync2, existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync11, rmSync as rmSync7, writeFileSync as writeFileSync8 } from "node:fs";
+import { cpSync as cpSync2, existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync12, rmSync as rmSync7, writeFileSync as writeFileSync8 } from "node:fs";
 import { dirname as dirname8, join as join14 } from "node:path";
 function installedAddonVersion(projectPath) {
   const marker = join14(projectPath, "addons", ADDONS2[0], VERSION_MARKER2);
   if (!existsSync11(marker)) {
     return null;
   }
-  const said = readFileSync11(marker, "utf8").trim();
+  const said = readFileSync12(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 var ADDONS2, VERSION_MARKER2 = ".gdharness-version";
@@ -35939,7 +35993,7 @@ var init_setup = __esm(() => {
 
 // src/server.ts
 import { execFile as execFile5, spawn } from "node:child_process";
-import { existsSync as existsSync12, mkdtempSync as mkdtempSync3, readdirSync as readdirSync6, readFileSync as readFileSync12, realpathSync as realpathSync2, rmSync as rmSync8 } from "node:fs";
+import { existsSync as existsSync12, mkdtempSync as mkdtempSync3, readdirSync as readdirSync6, readFileSync as readFileSync13, realpathSync as realpathSync2, rmSync as rmSync8 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
 import { basename as basename2, dirname as dirname9, join as join15, normalize as normalize3 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
@@ -35948,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":
@@ -36020,11 +36085,11 @@ function aboveTheRunner(entry) {
   };
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync12(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync13(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync12(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync13(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -36052,13 +36117,14 @@ class GodotServer {
   dapClient = null;
   bridgeStartupError = null;
   bridgeRetry = null;
+  successorWatch = null;
   lastProjectPath = null;
   shutdownInitiated = false;
   ownProject;
   announcedAt = null;
   constructor() {
     this.ownProject = envValue("GDHARNESS_PROJECT") ?? null;
-    this.godotBridge = getDefaultBridge(this.ownProject !== null);
+    this.godotBridge = getDefaultBridge(this.ownProject);
     this.mcp = new McpServer({ name: "gdharness", version: SERVER_VERSION }, { capabilities: { tools: {}, resources: {} } });
     this.setupToolHandlers();
     setupResourceHandlers(this.mcp, () => this.lastProjectPath);
@@ -36151,6 +36217,7 @@ class GodotServer {
       port: status.port,
       version: SERVER_VERSION
     });
+    this.watchForASuccessor();
   }
   stopTryingTheBridge() {
     if (this.bridgeRetry !== null) {
@@ -36158,9 +36225,41 @@ class GodotServer {
       this.bridgeRetry = null;
     }
   }
+  watchForASuccessor() {
+    if (this.ownProject === null || this.successorWatch !== null) {
+      return;
+    }
+    const watch = setInterval(() => {
+      const successor = this.supersededBy();
+      if (successor === null) {
+        return;
+      }
+      console.error(`[SERVER] pid ${successor} now serves ${this.ownProject}; this server is finished and is stopping.`);
+      this.handleShutdown(`superseded by ${successor}`, 0);
+    }, SUCCESSOR_CHECK_MS);
+    watch.unref();
+    this.successorWatch = watch;
+  }
+  supersededBy() {
+    if (this.ownProject === null) {
+      return null;
+    }
+    const announced = readAnnouncement(announcementPath(this.ownProject));
+    if (announced === null || announced.pid === process.pid) {
+      return null;
+    }
+    return alive(announced.pid) ? announced.pid : null;
+  }
+  stopWatchingForASuccessor() {
+    if (this.successorWatch !== null) {
+      clearInterval(this.successorWatch);
+      this.successorWatch = null;
+    }
+  }
   async cleanup() {
     this.logDebug("Cleaning up resources");
     this.stopTryingTheBridge();
+    this.stopWatchingForASuccessor();
     withdrawBridge(this.announcedAt);
     this.announcedAt = null;
     if (this.activeProcess) {
@@ -36742,7 +36841,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync12(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync13(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -36917,7 +37016,7 @@ class GodotServer {
       const written = existsSync12(reportsDir) ? readdirSync6(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
       const newest = written.at(-1);
       if (newest !== undefined) {
-        report = parseJUnit(readFileSync12(join15(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync13(join15(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -37116,7 +37215,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;
     }
@@ -37144,6 +37244,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()) {
@@ -37173,14 +37293,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) => {
@@ -37192,16 +37326,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);
@@ -37507,7 +37635,7 @@ class GodotServer {
       return {
         content: [
           { type: "text", text: `Screenshot captured: ${dimensions}` },
-          { type: "image", data: readFileSync12(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync13(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {
@@ -37573,7 +37701,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run5, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, SLOWEST_FRAME_RATE = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, HEADLESS_OPERATIONS, PROJECT_INFO_SECTIONS, RUNNER_DIRECTORY = "addons/gdUnit4/";
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run5, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, SLOWEST_FRAME_RATE = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, HEADLESS_OPERATIONS, PROJECT_INFO_SECTIONS, RUNNER_DIRECTORY = "addons/gdUnit4/";
 var init_server3 = __esm(() => {
   init_mcp();
   init_stdio2();
@@ -38322,27 +38450,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;
 }

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

@@ -18,9 +18,14 @@ const ANNOUNCE_PROTOCOL: int = 1
 const RECONNECT_DELAY: float = 3.0
 const MAX_RECONNECT_DELAY: float = 30.0
 
+## What a server closes with when the editor that said hello belongs to another project. Kept in
+## step with `OTHER_PROJECT_CLOSE_CODE` in src/godot-bridge.ts.
+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"
@@ -28,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.
 ##
@@ -67,13 +75,16 @@ var _since_looked: float = 0.0
 ## anything connects or the project names a different one.
 var _refused_url: String = ""
 var _tried_announced: bool = false
+
+## The address this editor has already been told is another project's, so a reconnect loop says it
+## once rather than every few seconds for the rest of the session.
+var _told_about_url: String = ""
 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
@@ -265,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)
@@ -343,12 +356,35 @@ func _loaded_version() -> String:
 
 func _handle_disconnect() -> void:
 	_is_connected = false
+	_said_elsewhere()
 	disconnected.emit()
 
 	if _should_reconnect:
 		_schedule_reconnect()
 
 
+## Says so when the server turned this editor away as another project's.
+##
+## The fallback address is tried by every project whose own server has not run yet and so has
+## announced nothing, which means any server holding it took the connection and served it. It is
+## refused now, and the refusal is worth a person's attention rather than a quiet backoff: nothing
+## about waiting reaches a server that is not this project's, and the answer is to start one.
+##
+## Said once per address. This is a reconnect loop, and a line every few seconds for the rest of
+## the session is a line nobody reads.
+func _said_elsewhere() -> void:
+	if socket.get_close_code() != ELSEWHERE_CLOSE_CODE:
+		return
+	if _told_about_url == server_url:
+		return
+	_told_about_url = server_url
+	var said: String = (
+		"[gdharness] %s is another project's server, so this editor is not connected: %s."
+		+ " Start this project's own server, or point it at one with GDHARNESS_BRIDGE_PORT."
+	)
+	push_warning(said % [server_url, socket.get_close_reason()])
+
+
 func _schedule_reconnect() -> void:
 	if _reconnect_timer == null:
 		return

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"],