gdharness 1.0.13 → 1.0.14

package/build/cli.js

@@ -31671,8 +31671,7 @@ function announcedAndGone(projectPath) {
     return [];
   }
   const since = Date.now() - GONE_WINDOW_MS;
-  const wanted = resolve3(projectPath);
-  return gone.filter((one) => one.noticedAt >= since && resolve3(one.project) === wanted);
+  return gone.filter((one) => one.noticedAt >= since && isSameDirectory(one.project, projectPath));
 }
 function strangersAmong(candidates, now, startTimes = startTimesOf) {
   const toJudge = candidates.filter((one) => {
@@ -31778,11 +31777,10 @@ function sweepErrorReport(path, pid, now = Date.now()) {
   } catch {}
 }
 async function announcedSince(projectPath, before, waiting = {}) {
-  const wanted = resolve3(projectPath);
   const directories = waiting.directories ?? runtimeDirectories();
   const until = Date.now() + Math.max(waiting.budgetMs ?? ANNOUNCE_BUDGET_MS, 0);
   for (;; ) {
-    const fresh = discoverRuntimes(directories).find((endpoint) => !before.has(endpoint.pid) && resolve3(endpoint.project.path) === wanted && (waiting.accept?.(endpoint) ?? true));
+    const fresh = discoverRuntimes(directories).find((endpoint) => !before.has(endpoint.pid) && isSameDirectory(endpoint.project.path, projectPath) && (waiting.accept?.(endpoint) ?? true));
     if (fresh !== undefined) {
       return fresh;
     }
@@ -31803,7 +31801,7 @@ function theOneProject(endpoints) {
   if (endpoints.some((endpoint) => endpoint.project.path === "")) {
     return;
   }
-  const paths = new Set(endpoints.map((endpoint) => resolve3(endpoint.project.path)));
+  const paths = new Set(endpoints.map((endpoint) => realPathOr(resolve3(endpoint.project.path))));
   const only = [...paths][0];
   return paths.size === 1 ? only : undefined;
 }
@@ -31832,7 +31830,7 @@ function chooseRuntime(endpoints, projectPath, unspoken = [], pid) {
   if (pid !== undefined) {
     const named = endpoints.find((endpoint) => endpoint.pid === pid);
     if (named !== undefined) {
-      if (projectPath !== undefined && resolve3(named.project.path) !== resolve3(projectPath)) {
+      if (projectPath !== undefined && !isSameDirectory(named.project.path, projectPath)) {
         return {
           problem: `The game with pid ${pid} is running ${named.project.path}, not ${resolve3(projectPath)}. Running: ${endpoints.map(describe2).join("; ")}.`
         };
@@ -31875,7 +31873,7 @@ function chooseRuntime(endpoints, projectPath, unspoken = [], pid) {
   }
   if (projectPath !== undefined) {
     const wanted = resolve3(projectPath);
-    const matching = endpoints.filter((endpoint) => resolve3(endpoint.project.path) === wanted);
+    const matching = endpoints.filter((endpoint) => isSameDirectory(endpoint.project.path, wanted));
     if (matching.length === 0) {
       return {
         problem: `No running game is from ${wanted}. Running: ${endpoints.map(describe2).join("; ")}.`
@@ -31986,6 +31984,7 @@ function runtimeRequest(endpoint, command, params, timeoutMs) {
 }
 var RUNTIME_PROTOCOL = 2, ANNOUNCEMENT_PATTERN, ERROR_REPORT_PATTERN, ERROR_REPORT_KEEP_MS, GONE_WINDOW_MS = 120000, GONE_KEPT = 32, gone, STARTED_AFTER_ANNOUNCING_MS = 2000, CONFIRMED_FOR_MS = 60000, JUDGED_AFTER_MS = 60000, verdicts, ENDED_WITHIN_MS = 3000, LOOK_EVERY_MS = 50, ANNOUNCE_BUDGET_MS = 5000, nextRequestId = 1;
 var init_runtime_client = __esm(() => {
+  init_paths();
   init_process_children();
   ANNOUNCEMENT_PATTERN = /^runtime-(\d+)\.json$/;
   ERROR_REPORT_PATTERN = /^runtime-(\d+)\.log$/;
@@ -41289,8 +41288,59 @@ class GodotServer {
     }
     return { heldAt: undefined, heldUnknown: true, heldNote: reply.message };
   }
+  async ownRunOnItsWay(projectPath, budgetMs) {
+    const run = this.currentRun();
+    const project = projectPath ?? run?.projectPath ?? null;
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync15(join22(project, RUNTIME_AUTOLOAD2.path)) || !await this.runStillGoing(run)) {
+      return null;
+    }
+    const already = runtimesAnnounced().running;
+    const announcedSinceTheStart = (one) => {
+      if (run.announcedBefore !== undefined) {
+        return !run.announcedBefore.has(one.pid);
+      }
+      try {
+        return statSync8(one.file).mtimeMs >= run.startedAt;
+      } catch {
+        return false;
+      }
+    };
+    if (already.some((one) => announcedSinceTheStart(one) && this.isTheGameOf(run, one, project))) {
+      return null;
+    }
+    const which = run.throughEditor ? "the game the editor is playing for it" : `pid ${run.pid ?? "unknown"}`;
+    const comingUpUntil = run.startedAt + waitSizedTo(readBootNote(project)) + budgetMs;
+    const remaining = comingUpUntil - Date.now();
+    if (remaining <= 0) {
+      const seconds = Math.round((Date.now() - run.startedAt) / 1000);
+      return `The game this server started (${which}) has been running for ${seconds}s and has not announced its runtime, so there is nothing to talk to. A game that keeps the runtime off, as a project's own loader can for some scenes, never announces; editor_output says what it has printed.`;
+    }
+    const endpoint = await announcedSince(project, new Set(already.map((one) => one.pid)), {
+      budgetMs: Math.min(budgetMs, remaining),
+      accept: (one) => this.isTheGameOf(this.currentRun(), one, project),
+      giveUp: () => this.currentRun() !== run || this.dapClient?.isStopped() === true || !stillRunning(run)
+    });
+    if (endpoint !== null) {
+      const tiedMeanwhile = () => run.announcedPid !== undefined;
+      if (!tiedMeanwhile()) {
+        this.tie(run, endpoint);
+      }
+      return null;
+    }
+    if (this.currentRun() !== run || !await this.runStillGoing(run)) {
+      return null;
+    }
+    return `The game this server started (${which}) is still coming up and has not announced its runtime after a wait of ${Math.min(budgetMs, remaining)}ms, so there is nothing to talk to yet. It is still running: ask again in a moment rather than starting another.`;
+  }
   async handleRuntimeCommand(command, args, timeoutMs = this.runtimeTimeoutMs()) {
     const { op: _op, projectPath, pid, ...params } = asParams(args);
+    const waited = typeof pid === "number" ? null : await this.ownRunOnItsWay(typeof projectPath === "string" ? projectPath : this.ownProject, timeoutMs);
+    if (waited !== null) {
+      return this.createErrorResponse(waited, [
+        "editor_status lists it under runtimes once it has announced",
+        "editor_output says what it has printed so far"
+      ]);
+    }
     const announced = runtimesAnnounced();
     const wanted = typeof projectPath === "string" ? projectPath : this.ownProject ?? undefined;
     const own = typeof pid === "number" ? undefined : this.ownGameAmong(announced.running, wanted) ?? await this.ownGameThroughTheTree(announced.running, wanted);

package/build/index.js

@@ -24770,7 +24770,7 @@ import { dirname as dirname2, join as join3 } from "node:path";
 import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync3, statSync, unlinkSync } from "node:fs";
 import { createConnection } from "node:net";
 import { tmpdir as tmpdir2 } from "node:os";
-import { dirname, join as join2, resolve } from "node:path";
+import { dirname, join as join2, resolve as resolve2 } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 
 // src/launch.ts
@@ -24837,6 +24837,65 @@ function environmentFor(options, variables = process.env) {
 }
 var SAVES_NOT_MOVED_NOTE = "On macOS the engine reads user:// off HOME and ignores the variables that move it elsewhere, measured on Godot 4.7.2, so this run wrote its saves where the player keeps theirs. A suite that saves a game has written into the same folder as the copy being played, and one that tidies up after itself may have removed real saves.";
 
+// src/paths.ts
+import { realpathSync } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+var RESOURCE_SCHEME = "res://";
+var OTHER_SCHEME = /^[a-zA-Z][a-zA-Z\d+.-]+:\/\//;
+function realPathOr(path) {
+  try {
+    return realpathSync.native(path);
+  } catch {
+    return path;
+  }
+}
+function isSameDirectory(onePath, otherPath) {
+  return relative(realPathOr(resolve(onePath)), realPathOr(resolve(otherPath))) === "";
+}
+function isWithinRoot(rootPath, candidatePath) {
+  const step = relative(resolve(rootPath), resolve(candidatePath));
+  return step !== ".." && !step.startsWith(`..${sep}`) && !isAbsolute(step);
+}
+function resolveWithinProject(projectPath, candidatePath) {
+  const trimmed = candidatePath.trim();
+  if (trimmed === "") {
+    return { ok: false, reason: "Path is empty." };
+  }
+  if (trimmed.includes("\x00")) {
+    return { ok: false, reason: "Path contains a null byte." };
+  }
+  const withoutScheme = trimmed.startsWith(RESOURCE_SCHEME) ? trimmed.slice(RESOURCE_SCHEME.length) : trimmed;
+  const scheme = OTHER_SCHEME.exec(withoutScheme);
+  if (scheme) {
+    return {
+      ok: false,
+      reason: `Path '${trimmed}' uses the '${scheme[0]}' scheme, which names somewhere other than this project.`
+    };
+  }
+  if (withoutScheme.startsWith("/") || withoutScheme.startsWith("\\") || isAbsolute(withoutScheme)) {
+    return {
+      ok: false,
+      reason: `Path '${trimmed}' is absolute; give a path inside the project, such as 'scenes/main.tscn'.`
+    };
+  }
+  if (withoutScheme.includes(":")) {
+    return {
+      ok: false,
+      reason: `Path '${trimmed}' contains ':', which no file inside a project is named with.`
+    };
+  }
+  const root = resolve(projectPath);
+  const absolutePath = resolve(root, withoutScheme);
+  if (!isWithinRoot(root, absolutePath)) {
+    return { ok: false, reason: `Path '${trimmed}' resolves outside the project directory.` };
+  }
+  const relativePath = relative(root, absolutePath).split(sep).join("/");
+  if (relativePath === "") {
+    return { ok: false, reason: `Path '${trimmed}' is the project directory itself, not a file in it.` };
+  }
+  return { ok: true, absolutePath, relativePath };
+}
+
 // src/process-children.ts
 import { execFile, execFileSync, spawnSync } from "node:child_process";
 import { basename } from "node:path";
@@ -25110,7 +25169,7 @@ function runtimeDirectories(variables = process.env) {
   for (const base of fallbacks) {
     candidates.push(join2(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
   }
-  return [...new Set(candidates.map((path) => resolve(path)))];
+  return [...new Set(candidates.map((path) => resolve2(path)))];
 }
 var ERROR_REPORT_PATTERN = /^runtime-(\d+)\.log$/;
 function errorReportOf(pid, directories = runtimeDirectories()) {
@@ -25205,8 +25264,7 @@ function announcedAndGone(projectPath) {
     return [];
   }
   const since = Date.now() - GONE_WINDOW_MS;
-  const wanted = resolve(projectPath);
-  return gone.filter((one) => one.noticedAt >= since && resolve(one.project) === wanted);
+  return gone.filter((one) => one.noticedAt >= since && isSameDirectory(one.project, projectPath));
 }
 var STARTED_AFTER_ANNOUNCING_MS = 2000;
 var CONFIRMED_FOR_MS = 60000;
@@ -25319,11 +25377,10 @@ function sweepErrorReport(path, pid, now = Date.now()) {
 var LOOK_EVERY_MS = 50;
 var ANNOUNCE_BUDGET_MS = 5000;
 async function announcedSince(projectPath, before, waiting = {}) {
-  const wanted = resolve(projectPath);
   const directories = waiting.directories ?? runtimeDirectories();
   const until = Date.now() + Math.max(waiting.budgetMs ?? ANNOUNCE_BUDGET_MS, 0);
   for (;; ) {
-    const fresh = discoverRuntimes(directories).find((endpoint) => !before.has(endpoint.pid) && resolve(endpoint.project.path) === wanted && (waiting.accept?.(endpoint) ?? true));
+    const fresh = discoverRuntimes(directories).find((endpoint) => !before.has(endpoint.pid) && isSameDirectory(endpoint.project.path, projectPath) && (waiting.accept?.(endpoint) ?? true));
     if (fresh !== undefined) {
       return fresh;
     }
@@ -25344,7 +25401,7 @@ function theOneProject(endpoints) {
   if (endpoints.some((endpoint) => endpoint.project.path === "")) {
     return;
   }
-  const paths = new Set(endpoints.map((endpoint) => resolve(endpoint.project.path)));
+  const paths = new Set(endpoints.map((endpoint) => realPathOr(resolve2(endpoint.project.path))));
   const only = [...paths][0];
   return paths.size === 1 ? only : undefined;
 }
@@ -25373,9 +25430,9 @@ function chooseRuntime(endpoints, projectPath, unspoken = [], pid) {
   if (pid !== undefined) {
     const named = endpoints.find((endpoint) => endpoint.pid === pid);
     if (named !== undefined) {
-      if (projectPath !== undefined && resolve(named.project.path) !== resolve(projectPath)) {
+      if (projectPath !== undefined && !isSameDirectory(named.project.path, projectPath)) {
         return {
-          problem: `The game with pid ${pid} is running ${named.project.path}, not ${resolve(projectPath)}. Running: ${endpoints.map(describe2).join("; ")}.`
+          problem: `The game with pid ${pid} is running ${named.project.path}, not ${resolve2(projectPath)}. Running: ${endpoints.map(describe2).join("; ")}.`
         };
       }
       return { endpoint: named };
@@ -25415,8 +25472,8 @@ function chooseRuntime(endpoints, projectPath, unspoken = [], pid) {
     };
   }
   if (projectPath !== undefined) {
-    const wanted = resolve(projectPath);
-    const matching = endpoints.filter((endpoint) => resolve(endpoint.project.path) === wanted);
+    const wanted = resolve2(projectPath);
+    const matching = endpoints.filter((endpoint) => isSameDirectory(endpoint.project.path, wanted));
     if (matching.length === 0) {
       return {
         problem: `No running game is from ${wanted}. Running: ${endpoints.map(describe2).join("; ")}.`
@@ -25560,67 +25617,6 @@ function waitSizedTo(lastBootMs, usual = ANNOUNCE_BUDGET_MS) {
 // src/breakpoint-note.ts
 import { mkdirSync as mkdirSync3, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
 import { dirname as dirname3, isAbsolute as isAbsolute2, join as join4, relative as relative2 } from "node:path";
-
-// src/paths.ts
-import { realpathSync } from "node:fs";
-import { isAbsolute, relative, resolve as resolve2, sep } from "node:path";
-var RESOURCE_SCHEME = "res://";
-var OTHER_SCHEME = /^[a-zA-Z][a-zA-Z\d+.-]+:\/\//;
-function realPathOr(path) {
-  try {
-    return realpathSync.native(path);
-  } catch {
-    return path;
-  }
-}
-function isSameDirectory(onePath, otherPath) {
-  return relative(realPathOr(resolve2(onePath)), realPathOr(resolve2(otherPath))) === "";
-}
-function isWithinRoot(rootPath, candidatePath) {
-  const step = relative(resolve2(rootPath), resolve2(candidatePath));
-  return step !== ".." && !step.startsWith(`..${sep}`) && !isAbsolute(step);
-}
-function resolveWithinProject(projectPath, candidatePath) {
-  const trimmed = candidatePath.trim();
-  if (trimmed === "") {
-    return { ok: false, reason: "Path is empty." };
-  }
-  if (trimmed.includes("\x00")) {
-    return { ok: false, reason: "Path contains a null byte." };
-  }
-  const withoutScheme = trimmed.startsWith(RESOURCE_SCHEME) ? trimmed.slice(RESOURCE_SCHEME.length) : trimmed;
-  const scheme = OTHER_SCHEME.exec(withoutScheme);
-  if (scheme) {
-    return {
-      ok: false,
-      reason: `Path '${trimmed}' uses the '${scheme[0]}' scheme, which names somewhere other than this project.`
-    };
-  }
-  if (withoutScheme.startsWith("/") || withoutScheme.startsWith("\\") || isAbsolute(withoutScheme)) {
-    return {
-      ok: false,
-      reason: `Path '${trimmed}' is absolute; give a path inside the project, such as 'scenes/main.tscn'.`
-    };
-  }
-  if (withoutScheme.includes(":")) {
-    return {
-      ok: false,
-      reason: `Path '${trimmed}' contains ':', which no file inside a project is named with.`
-    };
-  }
-  const root = resolve2(projectPath);
-  const absolutePath = resolve2(root, withoutScheme);
-  if (!isWithinRoot(root, absolutePath)) {
-    return { ok: false, reason: `Path '${trimmed}' resolves outside the project directory.` };
-  }
-  const relativePath = relative(root, absolutePath).split(sep).join("/");
-  if (relativePath === "") {
-    return { ok: false, reason: `Path '${trimmed}' is the project directory itself, not a file in it.` };
-  }
-  return { ok: true, absolutePath, relativePath };
-}
-
-// src/breakpoint-note.ts
 function breakpointNotePath(projectPath) {
   return join4(projectPath, ".godot", "gdharness-breakpoints.json");
 }
@@ -34030,8 +34026,59 @@ class GodotServer {
     }
     return { heldAt: undefined, heldUnknown: true, heldNote: reply.message };
   }
+  async ownRunOnItsWay(projectPath, budgetMs) {
+    const run = this.currentRun();
+    const project = projectPath ?? run?.projectPath ?? null;
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync10(join16(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
+      return null;
+    }
+    const already = runtimesAnnounced().running;
+    const announcedSinceTheStart = (one) => {
+      if (run.announcedBefore !== undefined) {
+        return !run.announcedBefore.has(one.pid);
+      }
+      try {
+        return statSync7(one.file).mtimeMs >= run.startedAt;
+      } catch {
+        return false;
+      }
+    };
+    if (already.some((one) => announcedSinceTheStart(one) && this.isTheGameOf(run, one, project))) {
+      return null;
+    }
+    const which = run.throughEditor ? "the game the editor is playing for it" : `pid ${run.pid ?? "unknown"}`;
+    const comingUpUntil = run.startedAt + waitSizedTo(readBootNote(project)) + budgetMs;
+    const remaining = comingUpUntil - Date.now();
+    if (remaining <= 0) {
+      const seconds = Math.round((Date.now() - run.startedAt) / 1000);
+      return `The game this server started (${which}) has been running for ${seconds}s and has not announced its runtime, so there is nothing to talk to. A game that keeps the runtime off, as a project's own loader can for some scenes, never announces; editor_output says what it has printed.`;
+    }
+    const endpoint = await announcedSince(project, new Set(already.map((one) => one.pid)), {
+      budgetMs: Math.min(budgetMs, remaining),
+      accept: (one) => this.isTheGameOf(this.currentRun(), one, project),
+      giveUp: () => this.currentRun() !== run || this.dapClient?.isStopped() === true || !stillRunning(run)
+    });
+    if (endpoint !== null) {
+      const tiedMeanwhile = () => run.announcedPid !== undefined;
+      if (!tiedMeanwhile()) {
+        this.tie(run, endpoint);
+      }
+      return null;
+    }
+    if (this.currentRun() !== run || !await this.runStillGoing(run)) {
+      return null;
+    }
+    return `The game this server started (${which}) is still coming up and has not announced its runtime after a wait of ${Math.min(budgetMs, remaining)}ms, so there is nothing to talk to yet. It is still running: ask again in a moment rather than starting another.`;
+  }
   async handleRuntimeCommand(command, args, timeoutMs = this.runtimeTimeoutMs()) {
     const { op: _op, projectPath, pid, ...params } = asParams(args);
+    const waited = typeof pid === "number" ? null : await this.ownRunOnItsWay(typeof projectPath === "string" ? projectPath : this.ownProject, timeoutMs);
+    if (waited !== null) {
+      return this.createErrorResponse(waited, [
+        "editor_status lists it under runtimes once it has announced",
+        "editor_output says what it has printed so far"
+      ]);
+    }
     const announced = runtimesAnnounced();
     const wanted = typeof projectPath === "string" ? projectPath : this.ownProject ?? undefined;
     const own = typeof pid === "number" ? undefined : this.ownGameAmong(announced.running, wanted) ?? await this.ownGameThroughTheTree(announced.running, wanted);

package/package.json

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