gdharness 1.2.26 → 1.2.27

package/build/index.js

@@ -27929,6 +27929,18 @@ class GodotDAPClient {
       lines: Array.from(lines).sort((a, b) => a - b)
     }));
   }
+  forgetBreakpoint(scriptPath, line) {
+    const key = fileKey(scriptPath);
+    const lines = this.breakpoints.get(key);
+    if (lines === undefined) {
+      return;
+    }
+    lines.delete(line);
+    if (lines.size === 0) {
+      this.breakpoints.delete(key);
+      this.spelled.delete(key);
+    }
+  }
   holdBreakpoints(held) {
     for (const { scriptPath, lines } of held) {
       const key = fileKey(scriptPath);
@@ -28707,6 +28719,22 @@ function howItEnded(run) {
   return run.exitSignal === null ? `exit code ${run.exitCode ?? "unknown"}` : `ended by ${run.exitSignal}`;
 }
 
+// src/godot-variant.ts
+var FLAG_64 = 1 << 16;
+var MOST_MESSAGE_BYTES = (8 << 20) + 4;
+
+// src/game-debugger.ts
+var PAUSE_MS = 30000;
+var STEP_MS = 1e4;
+var READ_MS = 5000;
+var REPLIES = new Set([
+  "debug_enter",
+  "debug_exit",
+  "stack_dump",
+  "stack_frame_vars",
+  "stack_frame_var"
+]);
+
 // src/godot-bridge.ts
 import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
@@ -30340,7 +30368,31 @@ function testProgressMessage(printed, elapsedMs) {
 
 // src/keeper-channel.ts
 import { connect, createServer as createServer2 } from "node:net";
-function askTheKeeperToStop(address, withinMs) {
+var DEBUG_PREFIX = "debug ";
+async function askTheKeeperToStop(address, withinMs) {
+  const answered = await askTheKeeper(address, "stop", withinMs);
+  if (typeof answered !== "string") {
+    return answered;
+  }
+  return answered === "signalled" || answered === "gone" ? answered : { unreached: `it answered ${JSON.stringify(answered)}` };
+}
+async function askTheKeepersDebugger(address, request, withinMs) {
+  const answered = await askTheKeeper(address, `${DEBUG_PREFIX}${JSON.stringify(request)}`, withinMs);
+  if (typeof answered !== "string") {
+    return answered;
+  }
+  if (answered === "unknown") {
+    return { unreached: "its keeper was started by a gdharness from before game debuggers, and has none" };
+  }
+  try {
+    const parsed = JSON.parse(answered);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {}
+  return { unreached: `it answered ${JSON.stringify(answered.slice(0, 200))}` };
+}
+function askTheKeeper(address, line, withinMs) {
   return new Promise((resolve) => {
     let said = "";
     let settled = false;
@@ -30358,16 +30410,15 @@ function askTheKeeperToStop(address, withinMs) {
     }, withinMs);
     socket.setEncoding("utf8");
     socket.on("connect", () => {
-      socket.write(`stop
+      socket.write(`${line}
 `);
     });
     socket.on("data", (chunk) => {
       said += chunk;
-      const line = said.split(`
-`)[0] ?? "";
       if (said.includes(`
 `)) {
-        settle(line === "signalled" || line === "gone" ? line : { unreached: `it answered ${JSON.stringify(line)}` });
+        settle(said.split(`
+`)[0] ?? "");
       }
     });
     socket.on("error", (error) => {
@@ -33868,12 +33919,6 @@ function withoutListed(entries, errors) {
 
 // src/script-profile.ts
 import { readFileSync as readFileSync19 } from "node:fs";
-
-// src/godot-variant.ts
-var FLAG_64 = 1 << 16;
-var MOST_MESSAGE_BYTES = (8 << 20) + 4;
-
-// src/script-profile.ts
 function readProfileFile(path) {
   try {
     const parsed = JSON.parse(readFileSync19(path, "utf8"));
@@ -34992,7 +35037,7 @@ var TOOL_SPECS = [
         type: "array",
         items: { type: "string" },
         ops: ["start", "check"],
-        description: `The game's own arguments, what OS.get_cmdline_user_args() answers, such as ["--level=2"]. The separator is added here, so a flag the engine reads goes to the game instead, and the answer says so under argsNote. A run with any is started by this server rather than by the editor, which fixes the game's command line when it opens the project, so the debug_* tools do not answer for it.`
+        description: `The game's own arguments, what OS.get_cmdline_user_args() answers, such as ["--level=2"]. The separator is added here, so a flag the engine reads goes to the game instead, and the answer says so under argsNote. A run with any is started by this server rather than by the editor, which fixes the game's command line when it opens the project, so its debugger is the keeper holding it rather than the editor; the debug_* tools answer for it all the same.`
       },
       engineArgs: {
         type: "array",
@@ -35009,7 +35054,7 @@ var TOOL_SPECS = [
       silent: {
         type: "boolean",
         ops: ["start"],
-        description: "start: run the game with no sound out of the machine, by starting the engine with --audio-driver Dummy: every stream still plays and every playback position still advances, so what is playing can still be asked. The editor takes no engine flags for a game it plays, so a silent windowed run is started by this server, and the debug_* tools do not answer for it. A headless run, check's included, is silent already. Default false, or true when GDHARNESS_SILENT is set in the server's environment to anything but 0 or false; silent: false then plays through the editor as before."
+        description: "start: run the game with no sound out of the machine, by starting the engine with --audio-driver Dummy: every stream still plays and every playback position still advances, so what is playing can still be asked. The editor takes no engine flags for a game it plays, so a silent windowed run is started by this server, whose keeper is its debugger rather than the editor. A headless run, check's included, is silent already. Default false, or true when GDHARNESS_SILENT is set in the server's environment to anything but 0 or false; silent: false then plays through the editor as before."
       },
       savesIn: {
         type: "string",
@@ -35690,7 +35735,7 @@ var TOOL_SPECS = [
   {
     name: "debug_breakpoint",
     title: "Breakpoints",
-    description: "Sets or removes a breakpoint through the editor's debug adapter. Needs the editor, not a running game: set them first, then editor_run, and the game stops where you asked. The editor keeps a breakpoint set this way for one play, so every breakpoint this server holds is sent again before each play editor_run starts, and the start answer lists them under breakpoints. The set is also kept in the project, for the server that comes after a reconnect: a breakpoint stays until it is removed here, whichever server set it. Every answer lists the whole set under held, and the breakpoints the user set in the editor's own gutter under setInEditor; setting one here never takes those away, and removing a line here clears it whoever set it. Godot clears every breakpoint in the editor when a debug session opens unless network/debug_adapter/sync_breakpoints is on, which the addon turns on as it loads; an editor running an older addon is said so under breakpointsAtRisk, here and in editor_status.",
+    description: "Sets or removes a breakpoint. Set them first, then editor_run, and the game stops where you asked. With the editor connected it goes through the editor's debug adapter; with none, it is held here. A game this server starts itself, which editor_run start does for a run given args, savesIn, env or silent, or with no editor, is handed every breakpoint held here as it starts, and one set while that game runs reaches it at once (runningGame says so). The editor keeps a breakpoint set this way for one play, so every breakpoint this server holds is sent again before each play editor_run starts, and the start answer lists them under breakpoints. The set is also kept in the project, for the server that comes after a reconnect: a breakpoint stays until it is removed here, whichever server set it. Every answer lists the whole set under held, and the breakpoints the user set in the editor's own gutter under setInEditor; setting one here never takes those away, and removing a line here clears it whoever set it. Godot clears every breakpoint in the editor when a debug session opens unless network/debug_adapter/sync_breakpoints is on, which the addon turns on as it loads; an editor running an older addon is said so under breakpointsAtRisk, here and in editor_status.",
     parameters: {
       projectPath: PROJECT_PATH2,
       scriptPath: SCRIPT_PATH,
@@ -35705,23 +35750,33 @@ var TOOL_SPECS = [
   {
     name: "debug_control",
     title: "Step the debugger",
-    description: "Continues or steps the debugged game through the editor's debug adapter. A step waits for the game to stop again and answers with the stack where it ended up; one that has not stopped the game again within ten seconds answers heldAgain false and no stack. There is no pause and no step_out: Godot's adapter answers a pause by reporting the game stopped and leaving it running, and implements no stepOut at all, so hold the game where you want it with a breakpoint and step over or into from there.",
+    description: "Pauses, continues or steps the debugged game. A step waits for the game to stop again and answers with the stack where it ended up; one that has not stopped the game again within ten seconds answers heldAgain false and no stack. A game the editor plays is moved through the editor's debug adapter, which cannot pause or step out: it answers a pause by reporting the game stopped and leaving it running, and implements no stepOut, so hold such a game with a breakpoint and step over or into from there. A game this server started itself has its keeper as its debugger, which does both: pause breaks into the game wherever it is, a script spinning in a loop included, which is how a game hung on its first frame is asked where it is.",
     parameters: {},
     requires: [],
     operations: {
+      pause: {
+        effect: "additive",
+        summary: "stop a game this server started where it is, answering with the stack. The game takes it between frames, and in a script every 2048 lines it runs, so a loop that sleeps between few lines can take seconds; the call waits thirty, and past that answers paused false with the request still standing. Stopped between frames, where no script runs, the game is stepped on to the next line of script it runs",
+        requires: []
+      },
       continue: { effect: "additive", summary: "resume after a breakpoint", requires: [] },
       step_over: { effect: "additive", summary: "run the current line", requires: [] },
       step_into: {
         effect: "additive",
         summary: "run the current line, stopping inside whatever it calls",
         requires: []
+      },
+      step_out: {
+        effect: "additive",
+        summary: "run to the end of the current function and stop in its caller; a game this server started only",
+        requires: []
       }
     }
   },
   {
     name: "debug_state",
     title: "Debugger state",
-    description: "Where the debugged game is stopped: the stack trace, what is in scope at a frame with the values, or the debug adapter's console output so far, its last thousand lines, with any earlier ones counted under notShown. A stop is reported by the editor's adapter only to the sessions connected when it happened, so a server that connected afterwards, which is every server after a reconnect, is shown a thread and no frames about a game still sitting at its breakpoint. That server asks the runtime instead: a held game accepts a connection and never answers, and the refusal then says held rather than running, and that the stack cannot be read from here. debug_control continue lets it go, and the next stop is one this session is told about, with its stack.",
+    description: "Where the debugged game is stopped: the stack trace, what is in scope at a frame with the values, or the debugger's console output so far, its last thousand lines, with any earlier ones counted under notShown. For a game this server started, its keeper's debugger answers: each frame names its script as the project spells it under script and on this machine under path, and held says which thread stopped and why. For a game the editor plays, the editor's debug adapter answers. A stop is reported by the editor's adapter only to the sessions connected when it happened, so a server that connected afterwards, which is every server after a reconnect, is shown a thread and no frames about a game still sitting at its breakpoint. That server asks the runtime instead: a held game accepts a connection and never answers, and the refusal then says held rather than running, and that the stack cannot be read from here. debug_control continue lets it go, and the next stop is one this session is told about, with its stack.",
     parameters: {
       frameId: {
         type: "number",
@@ -35811,7 +35866,7 @@ function serverInstructions() {
     "Call editor_status first: it says whether an editor is connected and whether its addon matches this server.",
     "Start the game with editor_run start, never by spawning an engine, and read editor_output after every run:",
     "its clean verdict and its error entries are how a run is judged, and editor_run wait is how to wait for one.",
-    "The runtime_* tools work on the running game and the debug_* tools on the editor's debugger.",
+    "The runtime_* tools work on the running game and the debug_* tools on its debugger.",
     "A refusal names what would have worked, so read it before calling again."
   ].join(" ");
 }
@@ -36152,6 +36207,31 @@ function longerWaitNote(tool, op, waitedMs) {
   const how = tool === "runtime_wait" && op === "frames" ? `the wait is counted from the number of frames, at ${SLOWEST_FRAME_RATE} a second on top of GDHARNESS_RUNTIME_TIMEOUT_MS: a game drawing frames more slowly than that is waited on in fewer frames at a time, and a game inside one long frame, such as a long _ready, answers no call however few frames are asked for` : "the wait is GDHARNESS_RUNTIME_TIMEOUT_MS, which is set in the environment the server is started with";
   return `${tool} ${op} takes no timeoutMs: it was given ${waitedMs}ms, and ${how}.`;
 }
+function keptGameRequest(tool, op, args) {
+  if (tool === "debug_state") {
+    if (op === "output") {
+      return { op: "output" };
+    }
+    if (op === "variables") {
+      const frame = args["frameId"];
+      return { op: "variables", frame: typeof frame === "number" ? frame : 0 };
+    }
+    return { op: "stack" };
+  }
+  switch (op) {
+    case "pause":
+      return { op: "pause" };
+    case "step_over":
+      return { op: "resume", how: "next" };
+    case "step_into":
+      return { op: "resume", how: "step" };
+    case "step_out":
+      return { op: "resume", how: "out" };
+    default:
+      return { op: "resume", how: "continue" };
+  }
+}
+var OWN_DEBUGGER = " Its debugger is the keeper holding it rather than the editor, so the debug_* tools answer for it all the same: breakpoints stop it, and debug_control pause breaks into it wherever it is, which the editor offers no way to do.";
 function projectSpelling(projectPath, absolutePath) {
   return `res://${relative4(realPathOr(projectPath), realPathOr(absolutePath)).replaceAll("\\", "/")}`;
 }
@@ -36239,6 +36319,7 @@ function stopWaitMs() {
   return waitFromEnv("GDHARNESS_STOP_WAIT_MS", 1e4);
 }
 var KEEPER_ANSWER_MS = 15000;
+var KEEPER_DEBUG_MS = PAUSE_MS + STEP_MS + 2 * READ_MS;
 var EXIT_REPORTED_WITHIN_MS = 2000;
 async function untilGone(pids, withinMs = stopWaitMs()) {
   const gone = () => pids.every((pid) => !alive(pid));
@@ -38139,28 +38220,70 @@ class GodotServer {
           return this.createErrorResponse(located.reason, PATH_SOLUTIONS);
         }
         const session = this.dapHoldingBreakpointsOf(project.value.path);
-        const answered = await this.handleDAP(op === "set" ? "dap_set_breakpoint" : "dap_remove_breakpoint", {
-          ...args,
-          scriptPath: realPathOr(located.absolutePath)
-        });
-        if (answered.isError === true) {
-          return answered;
+        const scriptPath = realPathOr(located.absolutePath);
+        const line = readPositiveNumber(args, "line");
+        if (line === undefined) {
+          return this.createErrorResponse("line is required: the one-based line to stop on.");
+        }
+        const editor = this.godotBridge.isConnected();
+        let answer;
+        if (editor) {
+          const answered = await this.handleDAP(op === "set" ? "dap_set_breakpoint" : "dap_remove_breakpoint", {
+            ...args,
+            scriptPath
+          });
+          if (answered.isError === true) {
+            return answered;
+          }
+          answer = asParams(JSON.parse(answered.content[0]?.text ?? "{}"));
+        } else {
+          if (op === "set") {
+            session.holdBreakpoints([{ scriptPath, lines: [line] }]);
+          } else {
+            session.forgetBreakpoint(scriptPath, line);
+          }
+          answer = { [op === "set" ? "set" : "removed"]: true };
         }
         const held = session.breakpointsHeld();
         writeBreakpointNote(project.value.path, held);
+        const kept = this.keptRun();
+        const told = kept === null ? null : await askTheKeepersDebugger(kept.keeper, {
+          op: "breakpoint",
+          script: projectSpelling(project.value.path, scriptPath),
+          line,
+          set: op === "set"
+        }, KEEPER_DEBUG_MS);
         return this.jsonTextResponse({
-          ...asParams(JSON.parse(answered.content[0]?.text ?? "{}")),
+          ...answer,
           held: this.breakpointsAsProjectSpells(project.value.path, held),
-          setInEditor: this.breakpointsAsProjectSpells(project.value.path, session.breakpointsInEditor()),
-          note: "The editor keeps a breakpoint set this way for one play. Every breakpoint held here is sent again before each play editor_run starts, and kept in the project for the server after a reconnect.",
-          ...this.breakpointsAtRisk()
+          ...editor ? {
+            setInEditor: this.breakpointsAsProjectSpells(project.value.path, session.breakpointsInEditor())
+          } : {},
+          ...told === null ? {} : ("unreached" in told) || typeof told["refused"] === "string" ? {
+            runningGame: `The game this server started is running, and its debugger was not told: ${String("unreached" in told ? told.unreached : told["refused"])}. It takes the line when it is started again.`
+          } : {
+            runningGame: `Told to the running game (pid ${kept?.pid ?? "?"}), which this server started.`
+          },
+          note: editor ? "The editor keeps a breakpoint set this way for one play. Every breakpoint held here is sent again before each play editor_run starts, handed to every game this server starts itself, and kept in the project for the server after a reconnect." : "No editor is connected, so the set under held is kept here: every game this server starts is handed it as it starts, an editor that connects is sent it before its first play, and it is kept in the project for the server after a reconnect.",
+          ...editor ? this.breakpointsAtRisk() : {}
         });
       }
       case "debug_control":
       case "debug_state": {
+        const kept = this.keptRun();
+        if (kept !== null) {
+          return await this.askTheKeptGame(kept.keeper, keptGameRequest(tool, op, args), kept.projectPath ?? "");
+        }
         if (tool === "debug_state" && op === "output") {
           return await this.handleDAP("dap_get_output", args);
         }
+        const played = this.activeProcess;
+        if ((op === "pause" || op === "step_out") && played?.throughEditor === true && !exited(played)) {
+          return this.createErrorResponse(op === "pause" ? "A game the editor plays cannot be paused from here: Godot's debug adapter answers a pause by reporting the game stopped and leaving it running." : "A game the editor plays cannot be stepped out of a function from here: Godot's debug adapter implements no stepOut.", [
+            "Set a breakpoint where it should stop, then step over or into from there",
+            "A game this server starts, as editor_run start does with args, savesIn or env, has a debugger here that pauses and steps out"
+          ]);
+        }
         const held = await this.debuggedGame(tool === "debug_control" ? "move" : "read");
         if (!held.ok) {
           return held.response;
@@ -38304,8 +38427,8 @@ class GodotServer {
     if (!game.throughEditor) {
       return {
         ok: false,
-        response: this.createErrorResponse("The running game is its own process, so no debugger is holding it: breakpoints never hit and there is no stack to read.", [
-          "editor_run start plays it through the open editor, whose debugger the debug_* tools speak to",
+        response: this.createErrorResponse("The running game has no debugger: it was started with none, or by a keeper that could not take questions, so breakpoints never hit and there is no stack to read.", [
+          "editor_run start starts it again, and the keeper holding a game this server starts is its debugger",
           "editor_status says whether an editor has reached this server"
         ])
       };
@@ -39516,6 +39639,38 @@ class GodotServer {
       breakpointsAtRisk: status.syncsBreakpoints === false ? "This editor clears every breakpoint in its script editor whenever a debug session opens on its adapter, which this server does for its first breakpoint or stack read: network/debug_adapter/sync_breakpoints is off. The installed addon turns it on as it loads, so the editor is running an older one; editor_launch restart puts the installed addon in, or turn the setting on in Editor Settings > Network > Debug Adapter." : "Whether this editor keeps its breakpoints when a debug session opens cannot be told: the addon it is running predates the report. Godot clears them unless network/debug_adapter/sync_breakpoints is on, which the installed addon turns on as it loads; editor_launch restart puts the installed addon in."
     };
   }
+  breakpointsForAGame(projectPath) {
+    return this.dapHoldingBreakpointsOf(projectPath).breakpointsHeld().flatMap((one) => one.lines.map((line) => `${projectSpelling(projectPath, one.scriptPath)}:${line}`));
+  }
+  keptRun() {
+    const game = this.activeProcess;
+    if (game === null || game.throughEditor || exited(game) || game.keeper === undefined) {
+      return null;
+    }
+    return { ...game, keeper: game.keeper };
+  }
+  async askTheKeptGame(keeper, request, projectPath) {
+    const answered = await askTheKeepersDebugger(keeper, request, KEEPER_DEBUG_MS);
+    if ("unreached" in answered) {
+      return this.createErrorResponse(`The debugger of the running game did not answer: ${String(answered.unreached)}.`, [
+        "editor_run start starts the game again, with a debugger",
+        "editor_status says whether it is still running"
+      ]);
+    }
+    if (typeof answered["refused"] === "string") {
+      return this.createErrorResponse(answered["refused"]);
+    }
+    const stack = answered["stack"];
+    return this.jsonTextResponse({
+      ...answered,
+      ...Array.isArray(stack) ? {
+        stack: stack.map((frame) => ({
+          ...frame,
+          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join23(projectPath, frame["script"].slice("res://".length)) } : {}
+        }))
+      } : {}
+    });
+  }
   breakpointsAsProjectSpells(projectPath, held) {
     return held.map((one) => ({
       scriptPath: projectSpelling(projectPath, one.scriptPath),
@@ -40177,9 +40332,10 @@ class GodotServer {
     started.announcedBefore = alreadyPlaying;
     started.bootScene = runtimeWaitMs.scene;
     this.activeProcess = started;
-    const spawnedInstead = this.godotBridge.isConnected() && editorWouldPlay && (given.value.length > 0 || flags.value.length > 0) ? " The editor cannot be handed arguments for a game it plays, so this one was started " + "here: the debug_* tools answer only for a game the editor is playing." : this.godotBridge.isConnected() && editorWouldPlay && needsItsOwnProcess(asked.value) ? " The editor plays a game with its own environment, so a run given one was started " + "here: the debug_* tools answer only for a game the editor is playing." : this.godotBridge.isConnected() && editorWouldPlay && silent ? " The editor cannot play a game silent, which takes an engine flag, so this one was " + `started here${args["silent"] === true ? "" : ", silent because GDHARNESS_SILENT says so"}: the debug_* tools answer only for a game the editor is playing, and silent: false plays it through the editor.` : "";
+    const spawnedInstead = this.godotBridge.isConnected() && editorWouldPlay && (given.value.length > 0 || flags.value.length > 0) ? ` The editor cannot be handed arguments for a game it plays, so this one was started here.${OWN_DEBUGGER}` : this.godotBridge.isConnected() && editorWouldPlay && needsItsOwnProcess(asked.value) ? ` The editor plays a game with its own environment, so a run given one was started here.${OWN_DEBUGGER}` : this.godotBridge.isConnected() && editorWouldPlay && silent ? " The editor cannot play a game silent, which takes an engine flag, so this one was " + `started here${args["silent"] === true ? "" : ", silent because GDHARNESS_SILENT says so"}, and silent: false plays it through the editor.${OWN_DEBUGGER}` : "";
     const endedForThis = endedToStartThis(ended);
     const stranded = wereHereFirst.filter((one) => one.pid !== ended?.pid && alive(one.pid));
+    const handed = this.dapHoldingBreakpointsOf(project.value.path).breakpointsHeld();
     const alsoRunning = leftRunningNote(stranded);
     return this.jsonTextResponse({
       started: true,
@@ -40189,6 +40345,7 @@ class GodotServer {
       arguments: cmdArgs,
       argsNote: engineFlagsNote(given.value),
       transcript: started.transcript,
+      breakpoints: started.keeper === undefined || handed.length === 0 ? undefined : this.breakpointsAsProjectSpells(project.value.path, handed),
       profile: profileOnStart(profiled, "gdharness", runtimeAddonRegistered(project.value.path)),
       refreshedClasses: refreshed.value,
       ...scanWaitAnswer(scanned),
@@ -40197,7 +40354,7 @@ class GodotServer {
       previousRunLeft: previousRunLeft(ended),
       ...previousRunHow(ended),
       runtime: await this.runtimeUp(project.value.path, alreadyPlaying, runtimeWaitMs, given.value.length > 0),
-      message: `Use editor_output for what it prints and editor_run stop to end it.${spawnedInstead}${endedForThis}${alsoRunning}`
+      message: `Use editor_output for what it prints and editor_run stop to end it.${started.keeper !== undefined && handed.length > 0 ? " It stops at the lines under breakpoints, and debug_state stack reads where it is held." : ""}${spawnedInstead}${endedForThis}${alsoRunning}`
     });
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
@@ -40724,7 +40881,8 @@ class GodotServer {
         startedAt,
         projectPath,
         ...this.servedBy(),
-        ...profile === undefined ? {} : { profile }
+        ...profile === undefined ? {} : { profile },
+        breakpoints: this.breakpointsForAGame(projectPath)
       },
       ...desktop === undefined ? {} : { desktop }
     });