breakpoint-mcp 1.78.3 → 1.80.0

package/dist/tools/csdap.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { DapError } from "../dap.js";
+import { DapError, DAP_TIMEOUT_CODE, unorderedHandshakeWarning } from "../dap.js";
+import { remedyClause } from "../bridge.js";
 import { resolveSourceFile } from "../paths.js";
 import { gate } from "../confirm.js";
 import { ok } from "./lsp-common.js";
@@ -32,15 +33,28 @@ function fail(err) {
             content: [{
                     type: "text",
                     text: `C# DAP error [${command}]: the debug adapter reported a failure with no message. ` +
-                        `The request was rejected; nothing was changed by it.`,
+                        `The request was rejected; nothing was changed by it.${remedyClause(err)}`,
                 }],
         };
     }
     return {
         isError: true,
-        content: [{ type: "text", text: `C# DAP error [${command}]: ${message}` }],
+        content: [{ type: "text", text: `C# DAP error [${command}]: ${message}${remedyClause(err)}` }],
     };
 }
+/**
+ * Record whether the adapter announced itself before its breakpoints were applied — the
+ * twin of `tools/dap.ts`'s, for the same measured reason (267). Kept per-plane rather than
+ * shared because the two planes' result objects are built by different code and a helper
+ * imported across them would be the only thing they share.
+ */
+function reportHandshakeOrder(result, seen, waitedMs) {
+    result.initialized_seen = seen;
+    if (seen)
+        return;
+    const note = unorderedHandshakeWarning(waitedMs);
+    result.warning = typeof result.warning === "string" && result.warning.length > 0 ? `${result.warning} ${note}` : note;
+}
 /** Throw a host refusal — rendered verbatim by `fail()`, never as an adapter error. */
 function refuse(message, code) {
     throw Object.assign(new Error(message), { refusal: true, code });
@@ -50,9 +64,13 @@ function refuse(message, code) {
  * adapter-reported failure or a dropped connection). Used to turn a
  * setVariable / evaluate non-response into a clear message rather than the
  * generic timeout — the same F1 discipline the GDScript DAP plane uses.
+ *
+ * 🔴 A CODE SINCE 268, A REGEX OVER ENGLISH BEFORE IT — see `tools/dap.ts`'s twin for
+ * the whole argument. Both planes carried the identical prose predicate, which is why
+ * the row named two files and not one.
  */
 function isDapTimeout(err) {
-    return err instanceof DapError && /timed out after/.test(err.message);
+    return err instanceof DapError && err.code === DAP_TIMEOUT_CODE;
 }
 /**
  * D4 C3 — the C#/.NET debugging plane. `cs_dbg_*` tools mirroring the read/inspect
@@ -239,14 +257,16 @@ export function registerCsDapTools(server, dap, cfg) {
             };
         }
         try {
-            await dap.start("launch", {
+            const { initializedSeen, initializedWaitMs } = await dap.start("launch", {
                 program: resolvedProgram,
                 args: resolvedArgs,
                 cwd: cfg.csDapProjectPath,
                 stopAtEntry: stop_on_entry ?? false,
                 justMyCode: just_my_code ?? true,
-            });
-            return ok({ session_id: "csharp", state: dap.state });
+            }, cfg.dapRequireInitialized);
+            const result = { session_id: "csharp", state: dap.state };
+            reportHandshakeOrder(result, initializedSeen, initializedWaitMs);
+            return ok(result);
         }
         catch (err) {
             return fail(err);
@@ -280,8 +300,10 @@ export function registerCsDapTools(server, dap, cfg) {
                         `was previously reported as "running" against a process that does not exist.`, "no_such_process");
                 }
             }
-            await dap.start("attach", { processId: process_id });
-            return ok({ session_id: "csharp", state: dap.state });
+            const { initializedSeen, initializedWaitMs } = await dap.start("attach", { processId: process_id }, cfg.dapRequireInitialized);
+            const result = { session_id: "csharp", state: dap.state };
+            reportHandshakeOrder(result, initializedSeen, initializedWaitMs);
+            return ok(result);
         }
         catch (err) {
             return fail(err);

package/dist/tools/dap.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { DapError } from "../dap.js";
+import { DapError, DAP_TIMEOUT_CODE, unorderedHandshakeWarning } from "../dap.js";
+import { remedyClause } from "../bridge.js";
 import { resolveSourceFile } from "../paths.js";
 import { gate } from "../confirm.js";
 import { ok } from "./lsp-common.js";
@@ -116,24 +117,38 @@ function fail(err) {
     // asked. Same distinction lsp-common.fail() already draws for the LSP planes.
     const e = err;
     if (err instanceof DapRefusal || e?.refusal) {
-        return { isError: true, content: [{ type: "text", text: e.message ?? String(err) }] };
+        return { isError: true, content: [{ type: "text", text: `${e.message ?? String(err)}${remedyClause(err)}` }] };
     }
     // An adapter can answer a failure with an EMPTY message (netcoredbg did, on
     // setVariable). `?? String(err)` only covers an ABSENT one, so the whole answer
     // became a label and a colon.
     const detail = e.message && e.message.trim() !== "" ? e.message : String(err);
+    // 🆕 267 — `remedyClause(err)` reads the `remedy` FIELD, which `DapError` gained this
+    // release. Before it, this plane's next actions were pasted inside the message at the
+    // raise site and this renderer had nothing to append; check 28 could not see them and a
+    // reword dropped one silently. Empty string when the site has no answer, so a rejection
+    // relaying the adapter's own words is byte-identical to what it was.
     return {
         isError: true,
-        content: [{ type: "text", text: `DAP error [${e.command ?? "error"}]: ${detail}` }],
+        content: [{ type: "text", text: `DAP error [${e.command ?? "error"}]: ${detail}${remedyClause(err)}` }],
     };
 }
 /**
  * True when `err` is a DAP request that hit its own request deadline (as opposed to an
  * adapter-reported failure or a dropped connection). Used to turn the setVariable /
  * evaluate hangs on advertised-but-unimplemented Godot builds into a clear message.
+ *
+ * 🔴 **THIS READ THE MESSAGE BODY UNTIL 268, AND TWO SHIPPED TOOLS BRANCHED ON IT.** The
+ * predicate was `/timed out after/.test(err.message)`, so `dbg_evaluate`'s and
+ * `dbg_set_variable`'s specific answers were selected by a regex over English — a copy
+ * edit at the raise site would have silently returned every caller to a bare timeout,
+ * with every test in the suite still green. 267 declined to reword those messages for
+ * exactly that reason and asserted the wording instead, which is a test defending a
+ * defect rather than a behaviour. The raise site now sets `DAP_TIMEOUT_CODE` and this
+ * reads it; check 32 refuses the regex coming back.
  */
 function isDapTimeout(err) {
-    return err instanceof DapError && /timed out after/.test(err.message);
+    return err instanceof DapError && err.code === DAP_TIMEOUT_CODE;
 }
 /**
  * 🔴 The modifier feature-detection lives in `dap.ts` (the client), NOT here, and that
@@ -144,6 +159,23 @@ function isDapTimeout(err) {
  * it, the breakpoint halted every frame, and the result carried no warning at all.
  * Detection now happens where the modifiers go on the wire, so every path gets it.
  */
+/**
+ * Record whether the adapter announced itself before its breakpoints were applied.
+ *
+ * 🔴 THE KEY IS ALWAYS PRESENT, THE WARNING ONLY WHEN IT IS FALSE (267). A field that
+ * appears only on the bad path is a field a caller cannot branch on — it cannot tell
+ * *this adapter was conformant* from *this host is too old to say* — which is the shape
+ * `required-any-reachability` is open about one layer up. The warning is the human half
+ * and merges rather than clobbers, for the same reason `reportDroppedModifiers` does:
+ * an out-of-order handshake and an unhonoured stop-on-entry can both be true at once.
+ */
+function reportHandshakeOrder(result, seen, waitedMs) {
+    result.initialized_seen = seen;
+    if (seen)
+        return;
+    const note = unorderedHandshakeWarning(waitedMs);
+    result.warning = typeof result.warning === "string" && result.warning.length > 0 ? `${result.warning} ${note}` : note;
+}
 const warnDropped = (dropped) => `The connected Godot debug adapter does not support ${dropped.join(", ")} on breakpoints (it advertises ` +
     `${dropped.length > 1 ? "them" : "it"} unsupported), so ${dropped.length > 1 ? "they were" : "it was"} dropped — ` +
     `the affected breakpoint(s) will halt unconditionally.`;
@@ -312,8 +344,9 @@ export function registerDapTools(server, dap, cfg) {
             };
         }
         try {
-            const { entryStopSeen } = await dap.start("launch", { project: cfg.projectPath, scene: scene ?? "main", stopOnEntry: stop_on_entry ?? false }, stop_on_entry ? ENTRY_STOP_WAIT_MS : 0);
+            const { entryStopSeen, initializedSeen, initializedWaitMs } = await dap.start("launch", { project: cfg.projectPath, scene: scene ?? "main", stopOnEntry: stop_on_entry ?? false }, stop_on_entry ? ENTRY_STOP_WAIT_MS : 0, cfg.dapRequireInitialized);
             const result = { session_id: "godot", state: dap.state, scene: scene ?? "main" };
+            reportHandshakeOrder(result, initializedSeen, initializedWaitMs);
             if (stop_on_entry) {
                 // 🔴 Measured on Godot 4.7: stopOnEntry is ignored outright — the game ran to
                 // completion and printed its _ready() line while the tool answered a bare
@@ -348,8 +381,9 @@ export function registerDapTools(server, dap, cfg) {
         },
     }, async ({ address, port }) => {
         try {
-            await dap.start("attach", { address: address ?? "127.0.0.1", port });
+            const { initializedSeen, initializedWaitMs } = await dap.start("attach", { address: address ?? "127.0.0.1", port }, 0, cfg.dapRequireInitialized);
             const result = { session_id: "godot", state: dap.state };
+            reportHandshakeOrder(result, initializedSeen, initializedWaitMs);
             reportDroppedModifiers(result);
             return ok(result);
         }

package/dist/tools/editor/common.js

@@ -1,10 +1,15 @@
 import { ok, failPath } from "../lsp-common.js";
 import { resolveInsideProject } from "../../paths.js";
-import { remedyClause } from "../../bridge.js";
+import { remedyClause, bridgeErrorLabel } from "../../bridge.js";
 /**
  * MCP error envelope for a failed editor-bridge call (never throws to the
  * caller). Distinct from lsp-common's `fail` (which labels errors "LSP error");
  * this one labels them "Bridge error".
+ *
+ * 🔴 THE LABEL IS BUILT BY `bridgeErrorLabel` AND NOT WRITTEN HERE (268), because
+ * `timeout-caveat.ts` matches against it to decide whether a mutating tool warns that
+ * a timed-out change may already have landed. Inlining the template again would put the
+ * two spellings back in two files with nothing joining them.
  */
 export function fail(err) {
     const be = err;
@@ -12,7 +17,7 @@ export function fail(err) {
     const message = be?.message ?? String(err);
     return {
         isError: true,
-        content: [{ type: "text", text: `Bridge error [${code}]: ${message}${remedyClause(err)}` }],
+        content: [{ type: "text", text: `${bridgeErrorLabel(code)}: ${message}${remedyClause(err)}` }],
     };
 }
 /**

package/dist/tools/lsp-common.js

@@ -4,6 +4,7 @@
 // MarkupContent), so these live once here rather than being duplicated per plane.
 // The generic MCP success-envelope helper `ok()` is the single shared envelope
 // shape and is imported by the other tool modules too, not only the LSP planes.
+import { remedyClause } from "../bridge.js";
 // LSP CompletionItemKind numeric -> readable name.
 export const COMPLETION_KIND = {
     1: "text", 2: "method", 3: "function", 4: "constructor", 5: "field", 6: "variable",
@@ -57,12 +58,14 @@ export function fail(err) {
     if (e?.refusal) {
         return {
             isError: true,
-            content: [{ type: "text", text: e.message ?? String(err) }],
+            content: [{ type: "text", text: `${e.message ?? String(err)}${remedyClause(err)}` }],
         };
     }
+    // 🆕 267 — see `tools/dap.ts`. `LspError` gained a `remedy` field this release; this is
+    // the one place both LSP planes render, so both get the clause from one edit.
     return {
         isError: true,
-        content: [{ type: "text", text: `LSP error [${e.code ?? "error"}]: ${e.message ?? String(err)}` }],
+        content: [{ type: "text", text: `LSP error [${e.code ?? "error"}]: ${e.message ?? String(err)}${remedyClause(err)}` }],
     };
 }
 /**
@@ -82,7 +85,7 @@ export function failPath(err) {
     const be = err;
     return {
         isError: true,
-        content: [{ type: "text", text: `Path error [${be?.code ?? "error"}]: ${be?.message ?? String(err)}` }],
+        content: [{ type: "text", text: `Path error [${be?.code ?? "error"}]: ${be?.message ?? String(err)}${remedyClause(err)}` }],
     };
 }
 /**

package/dist/tools/processes.js

@@ -157,7 +157,12 @@ export function registerProcessTools(server, cfg) {
         const since = since_seq ?? 0;
         const want = stream ?? "both";
         const lines = m.lines.filter((l) => l.seq > since && (want === "both" || l.stream === want));
-        return ok({ id, exited: m.exited, exit_code: m.exitCode, latest_seq: m.seq, lines });
+        // 🆕 267 — `signal` on the wire. `exit_code` alone could not distinguish a child
+        // that chose to exit 0 from one the OS killed: both answered `exited: true` with a
+        // null-or-number code, and a SIGKILLed child answered `exit_code: null`, which reads
+        // exactly like a process that has not finished. The registry has captured the signal
+        // since 266; this is the key that lets a caller read it.
+        return ok({ id, exited: m.exited, exit_code: m.exitCode, signal: m.exitSignal, latest_seq: m.seq, lines });
     });
     server.registerTool("godot_stop", {
         title: "Stop managed process",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "breakpoint-mcp",
-  "version": "1.78.3",
+  "version": "1.80.0",
   "description": "MCP server exposing Godot to AI coding assistants over the Model Context Protocol — developed and tested with Claude — across four planes (CLI, live editor, LSP+DAP, runtime) with elicitation-gated destructive tools, long jobs on the formal MCP task model, captured console output, and MCP resources.",
   "type": "module",
   "license": "MIT",
@@ -43,7 +43,8 @@
     "start": "node dist/index.js",
     "dev": "tsc && node dist/index.js",
     "stage-addon": "node scripts/stage-addon.mjs",
-    "prepublishOnly": "npm run build && npm run stage-addon",
+    "prepublishOnly": "npm run build && npm run stage-addon && node scripts/publish_guard.mjs",
+    "publish-guard": "node scripts/publish_guard.mjs --selftest && node scripts/publish_guard.mjs",
     "path-cohort": "node scripts/path-cohort.mjs",
     "tautology-gate": "node scripts/tautology_gate.selftest.mjs && node scripts/tautology_gate.mjs",
     "scope-gate": "python3 ../scripts/scope_gate.py",