breakpoint-mcp 1.19.1 → 1.23.0

package/dist/secret.js

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { randomBytes } from "node:crypto";
 /**
  * Loopback-bridge shared secret (host side).
  *
@@ -35,4 +36,52 @@ export function resolveBridgeSecret(projectPath, envNames) {
     }
     return readProjectSecret(projectPath);
 }
+/**
+ * Mint the per-project secret if it does not exist yet, and return it (or the
+ * existing one). Returns null if the file can neither be read nor written — the
+ * caller then proceeds exactly as before, with the child minting its own.
+ *
+ * Why the HOST mints it, ahead of spawning peers (F6 spike, constraint 2):
+ * `BridgeSecret.load_or_mint()` in the addon is a check-then-write with no lock
+ * — `file_exists → read` ELSE `mint → write`. F6 spawns N children through one
+ * funnel, so on a COLD project every child can reach the mint branch before any
+ * of them has written. Two peers minting different secrets, each holding its own
+ * in memory while the last writer wins on disk, is a peer the host can never
+ * authenticate against — and it presents as a flaky spawn, not a clear error.
+ * Measured 6/6 clean at 3 simultaneous peers, but that is Godot's ~200 ms init
+ * versus a sub-millisecond mint, i.e. timing, not a guarantee; the window is
+ * structurally open and would surface on someone else's slower machine.
+ *
+ * Writing the file first closes it by construction: every child then takes the
+ * `file_exists` path (verified 4/4 in the spike, with the file untouched after).
+ * An EXISTING secret is never overwritten — the editor may have minted it, and
+ * all three parties must agree on one value.
+ *
+ * Format matches `addons/breakpoint_mcp/bridge_secret.gd` exactly: 32 random
+ * bytes, hex-encoded to 64 characters, at `<projectPath>/.godot/breakpoint_mcp.secret`.
+ * Note the addon's `_setup_auth()` does NOT read the env overrides — they are
+ * host-side only — so the FILE is the mechanism for a host-launched child.
+ */
+export function ensureProjectSecret(projectPath) {
+    const existing = readProjectSecret(projectPath);
+    if (existing)
+        return existing;
+    try {
+        const dir = path.join(projectPath, ".godot");
+        fs.mkdirSync(dir, { recursive: true });
+        const secret = randomBytes(32).toString("hex");
+        // wx: never clobber a secret another process minted between the read above
+        // and this write — losing that race must be a no-op, not an overwrite.
+        try {
+            fs.writeFileSync(path.join(dir, "breakpoint_mcp.secret"), secret, { encoding: "utf8", flag: "wx", mode: 0o600 });
+            return secret;
+        }
+        catch {
+            return readProjectSecret(projectPath);
+        }
+    }
+    catch {
+        return null;
+    }
+}
 //# sourceMappingURL=secret.js.map

package/dist/tools/processes.js

@@ -12,11 +12,23 @@ const LINE_CAP = 5000;
 export class ProcessRegistry {
     procs = new Map();
     counter = 0;
-    run(cfg, extraArgs) {
+    /**
+     * Spawn a managed Godot child. `env` is an OVERLAY on the inherited
+     * environment, not a replacement: omitted (the `godot_run_managed` path) the
+     * child inherits exactly as before, byte-identical to pre-F6 behaviour.
+     *
+     * The overlay is what makes multi-peer work at all — the runtime autoload
+     * reads `BREAKPOINT_RUNTIME_PORT` from its environment
+     * (`runtime_bridge.gd:74`), so N addressable peers is a per-child env
+     * passthrough plus a port allocator, with no protocol, transport or handshake
+     * change. See `peers.ts`.
+     */
+    run(cfg, extraArgs, env) {
         const id = `godot-${++this.counter}`;
         const child = spawn(cfg.godotBin, ["--path", cfg.projectPath, ...extraArgs], {
             cwd: cfg.projectPath,
             stdio: ["ignore", "pipe", "pipe"],
+            ...(env ? { env: { ...process.env, ...env } } : {}),
         });
         const m = { id, child, lines: [], seq: 0, exited: false, exitCode: null };
         const ingest = (stream) => (buf) => {
@@ -43,6 +55,18 @@ export class ProcessRegistry {
     get(id) {
         return this.procs.get(id);
     }
+    /**
+     * The last `n` captured lines for a managed child, newest last. Used to
+     * explain a peer that never bound its port — a project that fails to load
+     * dies with the reason on stderr, and without this the caller only ever sees
+     * "cannot reach the runtime bridge".
+     */
+    tail(id, n = 12) {
+        const m = this.procs.get(id);
+        if (!m)
+            return [];
+        return m.lines.slice(-n).map((l) => l.text);
+    }
     killAll() {
         for (const m of this.procs.values()) {
             try {