breakpoint-mcp 1.0.0

package/dist/dap.js

@@ -0,0 +1,341 @@
+import { EventEmitter } from "node:events";
+import { FramedConnection } from "./framing.js";
+export class DapError extends Error {
+    command;
+    constructor(command, message) {
+        super(message);
+        this.command = command;
+        this.name = "DapError";
+    }
+}
+/**
+ * Minimal DAP client for Godot's Debug Adapter (raw TCP + DAP framing). Runs the
+ * initialize → (breakpoints) → configurationDone → launch/attach handshake, and
+ * tracks execution state from `stopped`/`terminated` events. One session.
+ */
+export class DapClient extends EventEmitter {
+    timeoutMs;
+    conn;
+    seq = 1;
+    pending = new Map();
+    breakpoints = new Map();
+    configured = false;
+    /** Persistent watch expressions, re-evaluated at each stop (see evaluateWatches). */
+    watches = [];
+    /** The mode + args of the last start(), so restart() can reuse/override them. */
+    lastStartMode = null;
+    lastStartArgs = null;
+    capabilities = null;
+    state = "disconnected";
+    lastStoppedThreadId = null;
+    lastStoppedReason = null;
+    constructor(host, port, timeoutMs) {
+        super();
+        this.timeoutMs = timeoutMs;
+        this.conn = new FramedConnection(host, port, "DAP", "Is the editor running with the Debug Adapter enabled (Editor Settings → Network → Debug Adapter, port 6006)?");
+        this.conn.onMessage((m) => this.onMessage(m));
+        this.conn.onClose(() => {
+            this.state = "terminated";
+            this.configured = false;
+            for (const [, p] of this.pending) {
+                clearTimeout(p.timer);
+                p.reject(new DapError(p.command, "DAP connection closed"));
+            }
+            this.pending.clear();
+            this.emit("closed");
+        });
+    }
+    onMessage(msg) {
+        const type = msg["type"];
+        if (type === "response") {
+            const reqSeq = msg["request_seq"];
+            const p = this.pending.get(reqSeq);
+            if (!p)
+                return;
+            this.pending.delete(reqSeq);
+            clearTimeout(p.timer);
+            if (msg["success"]) {
+                p.resolve((msg["body"] ?? {}));
+            }
+            else {
+                p.reject(new DapError(String(msg["command"] ?? p.command), String(msg["message"] ?? "DAP request failed")));
+            }
+        }
+        else if (type === "event") {
+            this.onEvent(String(msg["event"]), (msg["body"] ?? {}));
+        }
+        else if (type === "request") {
+            // Reverse request (e.g. runInTerminal). Ack success so we don't stall.
+            void this.conn.send({
+                seq: this.seq++,
+                type: "response",
+                request_seq: msg["seq"],
+                success: true,
+                command: msg["command"],
+            });
+        }
+    }
+    onEvent(event, body) {
+        switch (event) {
+            case "initialized":
+                this.emit("initialized");
+                break;
+            case "stopped":
+                this.state = "stopped";
+                this.lastStoppedThreadId = body["threadId"] ?? this.lastStoppedThreadId ?? 1;
+                this.lastStoppedReason = body["reason"] ?? null;
+                this.emit("stopped", body);
+                break;
+            case "continued":
+                this.state = "running";
+                break;
+            case "terminated":
+            case "exited":
+                this.state = "terminated";
+                this.emit("terminated", body);
+                break;
+            case "output":
+                this.emit("output", body);
+                break;
+            default:
+                break;
+        }
+    }
+    request(command, args = {}, timeoutMs = this.timeoutMs) {
+        const seq = this.seq++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(seq);
+                reject(new DapError(command, `DAP '${command}' timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            this.pending.set(seq, { command, resolve: resolve, reject, timer });
+            this.conn.send({ seq, type: "request", command, arguments: args }).catch((err) => {
+                clearTimeout(timer);
+                this.pending.delete(seq);
+                reject(err);
+            });
+        });
+    }
+    waitEvent(name, timeoutMs) {
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.removeListener(name, onEvent);
+                resolve();
+            }, timeoutMs);
+            const onEvent = () => {
+                clearTimeout(timer);
+                resolve();
+            };
+            this.once(name, onEvent);
+        });
+    }
+    /** Store breakpoints; apply immediately if the session is already configured. */
+    async setBreakpoints(path, lines, conditions, hitConditions, logMessages) {
+        this.breakpoints.set(path, { path, lines, conditions, hitConditions, logMessages });
+        if (this.configured) {
+            return this.applyBreakpoints(path);
+        }
+        return { buffered: true, path, lines };
+    }
+    applyBreakpoints(path) {
+        const bp = this.breakpoints.get(path);
+        if (!bp)
+            return Promise.resolve({});
+        return this.request("setBreakpoints", {
+            source: { path },
+            // DAP SourceBreakpoint: line + optional condition / hitCondition / logMessage.
+            // A logMessage turns the breakpoint into a logpoint (adapter logs, doesn't halt).
+            breakpoints: bp.lines.map((line, i) => {
+                const b = { line };
+                const condition = bp.conditions?.[i];
+                const hit = bp.hitConditions?.[i];
+                const log = bp.logMessages?.[i];
+                if (condition)
+                    b.condition = condition;
+                if (hit)
+                    b.hitCondition = hit;
+                if (log)
+                    b.logMessage = log;
+                return b;
+            }),
+        });
+    }
+    // ---- Watch expressions ---------------------------------------------------
+    /** Add expressions to the persistent watch set (deduped, order-preserving). */
+    addWatches(expressions) {
+        for (const e of expressions)
+            if (e && !this.watches.includes(e))
+                this.watches.push(e);
+    }
+    /** Remove specific expressions from the watch set. */
+    removeWatches(expressions) {
+        const drop = new Set(expressions);
+        this.watches = this.watches.filter((e) => !drop.has(e));
+    }
+    /** Clear all watch expressions. */
+    clearWatches() {
+        this.watches = [];
+    }
+    /** The current watch set (a copy). */
+    listWatches() {
+        return [...this.watches];
+    }
+    /**
+     * Evaluate every watch expression in the context of a stopped frame and return
+     * the results. Each expression is evaluated with DAP `context: "watch"` (the
+     * side-effect-free evaluation context IDEs use for watch panels). A single bad
+     * expression yields an `error` on that entry instead of failing the whole call.
+     *
+     * `timeoutMs` bounds each individual `evaluate` request (defaults to the client's full
+     * `timeoutMs`). Callers pass the shorter `dapEvaluateTimeoutMs` so a watch expression the
+     * adapter never answers fails fast on that entry — mirroring `dbg_evaluate` — instead of
+     * hanging the full 20 s DAP timeout per stalling expression at every stop.
+     */
+    async evaluateWatches(frameId, timeoutMs = this.timeoutMs) {
+        const results = [];
+        for (const expression of this.watches) {
+            try {
+                const body = await this.request("evaluate", { expression, frameId, context: "watch" }, timeoutMs);
+                results.push({
+                    expression,
+                    value: String(body["result"] ?? ""),
+                    type: String(body["type"] ?? ""),
+                    error: null,
+                });
+            }
+            catch (err) {
+                const e = err;
+                results.push({ expression, value: "", type: "", error: e.message ?? String(err) });
+            }
+        }
+        return results;
+    }
+    async applyAllBreakpoints() {
+        for (const path of this.breakpoints.keys()) {
+            await this.applyBreakpoints(path).catch(() => undefined);
+        }
+    }
+    /** Full handshake: initialize → launch/attach → (breakpoints) → configurationDone. */
+    async start(mode, args) {
+        // Remember how we started so restart() can reuse (or override) these params.
+        this.lastStartMode = mode;
+        this.lastStartArgs = args;
+        // Listen for `initialized` before we ask, so we cannot miss it.
+        const onInit = this.waitEvent("initialized", Math.min(this.timeoutMs, 5000));
+        this.capabilities = await this.request("initialize", {
+            clientID: "breakpoint-mcp",
+            clientName: "Godot Breakpoint MCP",
+            adapterID: "godot",
+            pathFormat: "path",
+            linesStartAt1: true,
+            columnsStartAt1: true,
+            supportsRunInTerminalRequest: false,
+        });
+        this.state = "initialized";
+        // Send launch/attach but don't await it yet — many adapters only resolve it
+        // after configurationDone.
+        const startReq = this.request(mode, args);
+        await onInit;
+        await this.applyAllBreakpoints();
+        await this.request("configurationDone", {}).catch(() => undefined);
+        this.configured = true;
+        this.state = "running";
+        // Surface a launch/attach failure if one occurs, but don't hang on success.
+        startReq.catch((err) => this.emit("error", err));
+    }
+    threadId() {
+        return this.lastStoppedThreadId ?? 1;
+    }
+    /**
+     * Issue a resume command (continue / next / stepIn / stepOut) and wait for the
+     * program to settle again — i.e. the next `stopped` (hit a breakpoint / step
+     * landed) or `terminated` event — before returning. Without this, step/continue
+     * returned instantly with a stale "running"/"stopped" state and no location.
+     *
+     * The stop listener is armed BEFORE the command is sent so a fast stop can't be
+     * missed. If nothing settles within `waitMs` (e.g. `continue` runs on with no
+     * further breakpoint), it resolves with the current state ("running").
+     */
+    async resume(command, args, waitMs) {
+        const settled = new Promise((resolve) => {
+            const finish = () => {
+                clearTimeout(timer);
+                this.removeListener("stopped", onStop);
+                this.removeListener("terminated", onTerm);
+                resolve({ state: this.state, reason: this.lastStoppedReason });
+            };
+            const onStop = () => finish();
+            const onTerm = () => finish();
+            const timer = setTimeout(() => {
+                this.removeListener("stopped", onStop);
+                this.removeListener("terminated", onTerm);
+                resolve({ state: this.state, reason: this.lastStoppedReason });
+            }, waitMs);
+            this.once("stopped", onStop);
+            this.once("terminated", onTerm);
+        });
+        // Optimistically mark running so a stale "stopped" isn't reported back.
+        this.state = "running";
+        await this.request(command, args);
+        return settled;
+    }
+    /**
+     * Resolve when the program next settles (a `stopped` or `terminated` event) or
+     * `waitMs` elapses, whichever comes first — the shared wait used after a resume
+     * or a restart. Listeners are armed by the caller BEFORE the triggering request
+     * is sent so a fast settle can't be missed.
+     */
+    settle(waitMs) {
+        return new Promise((resolve) => {
+            const finish = () => {
+                clearTimeout(timer);
+                this.removeListener("stopped", onStop);
+                this.removeListener("terminated", onTerm);
+                resolve({ state: this.state, reason: this.lastStoppedReason });
+            };
+            const onStop = () => finish();
+            const onTerm = () => finish();
+            const timer = setTimeout(() => {
+                this.removeListener("stopped", onStop);
+                this.removeListener("terminated", onTerm);
+                resolve({ state: this.state, reason: this.lastStoppedReason });
+            }, waitMs);
+            this.once("stopped", onStop);
+            this.once("terminated", onTerm);
+        });
+    }
+    /**
+     * Restart the debug session. If the adapter advertises `supportsRestartRequest`,
+     * issue a single DAP `restart` (carrying the launch/attach args); otherwise fall
+     * back to `terminate` + a fresh handshake, so restart works on every adapter.
+     * Reuses the last dbg_launch/dbg_attach params; `overrideArgs` (e.g. a new scene
+     * or stopOnEntry) are merged over them. `method` tells the caller which path ran.
+     */
+    async restart(overrideArgs = {}, waitMs = 15000) {
+        if (!this.lastStartMode || !this.lastStartArgs) {
+            throw new DapError("restart", "no debug session to restart — call dbg_launch or dbg_attach first");
+        }
+        const args = { ...this.lastStartArgs, ...overrideArgs };
+        const scene = typeof args["scene"] === "string" ? args["scene"] : null;
+        if (this.capabilities?.["supportsRestartRequest"] === true) {
+            // Arm the settle listener before issuing restart so a fast stop isn't missed.
+            const settled = this.settle(waitMs);
+            this.state = "running";
+            await this.request("restart", { arguments: args });
+            this.lastStartArgs = args;
+            const r = await settled;
+            return { method: "restart", state: r.state, reason: r.reason, scene };
+        }
+        // Fallback: ask the debuggee to terminate (best-effort), then re-run the full
+        // initialize → launch/attach → configurationDone handshake with the same args.
+        await this.request("terminate", {}).catch(() => undefined);
+        await this.start(this.lastStartMode, args);
+        return { method: "relaunch", state: this.state, reason: this.lastStoppedReason, scene };
+    }
+    close() {
+        this.conn.close();
+        this.state = "disconnected";
+        this.configured = false;
+    }
+}
+//# sourceMappingURL=dap.js.map

package/dist/framing.js

@@ -0,0 +1,125 @@
+import net from "node:net";
+import { log } from "./logger.js";
+/** Serialize a JSON message as an LSP/DAP `Content-Length` frame. */
+export function encodeFrame(msg) {
+    const body = Buffer.from(JSON.stringify(msg), "utf8");
+    const header = Buffer.from(`Content-Length: ${body.length}\r\n\r\n`, "ascii");
+    return Buffer.concat([header, body]);
+}
+/**
+ * Incremental `Content-Length` frame decoder. Feed it chunks (from a socket or a
+ * child process's stdout) with `push`; it invokes `onMessage` for every complete
+ * JSON body and buffers the remainder. A malformed header block is skipped so the
+ * stream resyncs rather than wedging. Factored out of `FramedConnection` so the
+ * stdio transport reuses the exact same, tested, framing.
+ */
+export class FrameDecoder {
+    onMessage;
+    label;
+    buffer = Buffer.alloc(0);
+    constructor(onMessage, label) {
+        this.onMessage = onMessage;
+        this.label = label;
+    }
+    push(chunk) {
+        const buf = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
+        this.buffer = Buffer.concat([this.buffer, buf]);
+        for (;;) {
+            const headerEnd = this.buffer.indexOf("\r\n\r\n");
+            if (headerEnd === -1)
+                return;
+            const header = this.buffer.subarray(0, headerEnd).toString("ascii");
+            const match = /Content-Length:\s*(\d+)/i.exec(header);
+            if (!match) {
+                // Malformed header block — skip it and resync.
+                this.buffer = this.buffer.subarray(headerEnd + 4);
+                continue;
+            }
+            const length = Number.parseInt(match[1], 10);
+            const bodyStart = headerEnd + 4;
+            if (this.buffer.length < bodyStart + length)
+                return; // wait for the rest
+            const body = this.buffer.subarray(bodyStart, bodyStart + length).toString("utf8");
+            this.buffer = this.buffer.subarray(bodyStart + length);
+            try {
+                this.onMessage(JSON.parse(body));
+            }
+            catch {
+                log(`${this.label} received unparseable frame (${length} bytes)`);
+            }
+        }
+    }
+    reset() {
+        this.buffer = Buffer.alloc(0);
+    }
+}
+/**
+ * Raw-TCP transport with LSP/DAP `Content-Length` framing:
+ *
+ *   Content-Length: <n>\r\n\r\n<n bytes of UTF-8 JSON>
+ *
+ * Godot serves BOTH its GDScript language server (LSP, JSON-RPC 2.0) and its
+ * Debug Adapter (DAP, seq/type/command) this way, so this one class underpins
+ * both protocol clients. Connects lazily on first send; reconnects after drop.
+ */
+export class FramedConnection {
+    host;
+    port;
+    label;
+    unavailableHint;
+    socket = null;
+    connecting = null;
+    decoder;
+    messageCb = () => { };
+    closeCb = () => { };
+    constructor(host, port, label, unavailableHint) {
+        this.host = host;
+        this.port = port;
+        this.label = label;
+        this.unavailableHint = unavailableHint;
+        this.decoder = new FrameDecoder((m) => this.messageCb(m), label);
+    }
+    onMessage(cb) {
+        this.messageCb = cb;
+    }
+    onClose(cb) {
+        this.closeCb = cb;
+    }
+    connect() {
+        if (this.socket && !this.socket.destroyed)
+            return Promise.resolve(this.socket);
+        if (this.connecting)
+            return this.connecting;
+        this.connecting = new Promise((resolve, reject) => {
+            const socket = net.createConnection({ host: this.host, port: this.port });
+            socket.setNoDelay(true);
+            socket.once("connect", () => {
+                this.socket = socket;
+                this.connecting = null;
+                log(`${this.label} connected to ${this.host}:${this.port}`);
+                resolve(socket);
+            });
+            socket.once("error", (err) => {
+                this.connecting = null;
+                reject(new Error(`${this.label} unavailable at ${this.host}:${this.port}. ${this.unavailableHint} (${err.message})`));
+            });
+            socket.on("data", (chunk) => this.decoder.push(chunk));
+            socket.on("close", () => {
+                this.socket = null;
+                this.decoder.reset();
+                this.closeCb();
+            });
+        });
+        return this.connecting;
+    }
+    async send(msg) {
+        const socket = await this.connect();
+        socket.write(encodeFrame(msg));
+    }
+    close() {
+        if (this.socket)
+            this.socket.destroy();
+        this.socket = null;
+    }
+}
+//# sourceMappingURL=framing.js.map

package/dist/index.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { envCompat, loadConfig } from "./config.js";
+import { BridgeClient } from "./bridge.js";
+import { LspClient } from "./lsp.js";
+import { CsLspClient } from "./cslsp.js";
+import { CsDapClient } from "./csdap.js";
+import { StdioChannel } from "./stdio.js";
+import { DapClient } from "./dap.js";
+import { registerCliTools } from "./tools/cli.js";
+import { registerEditorTools } from "./tools/editor.js";
+import { registerLspTools } from "./tools/lsp.js";
+import { registerCsLspTools } from "./tools/cslsp.js";
+import { registerDapTools } from "./tools/dap.js";
+import { registerCsDapTools } from "./tools/csdap.js";
+import { registerRuntimeTools } from "./tools/runtime.js";
+import { registerProcessTools } from "./tools/processes.js";
+import { registerKnowledgeTools } from "./tools/knowledge.js";
+import { registerAssetGenTools } from "./tools/assetgen.js";
+import { registerNetcodeTools } from "./tools/netcode.js";
+import { registerBackendTools } from "./tools/backend.js";
+import { registerResources } from "./tools/resources.js";
+import { applyOutputSchemas } from "./schemas.js";
+import { taskStore, TASK_CAPABILITIES } from "./tasks.js";
+import { RESOURCE_CAPABILITIES, registerResourceSubscriptions } from "./subscriptions.js";
+import { log } from "./logger.js";
+async function main() {
+    const config = loadConfig();
+    const bridge = new BridgeClient(config.bridgeHost, config.bridgePort, config.bridgeTimeoutMs);
+    const runtime = new BridgeClient(config.runtimeHost, config.runtimePort, config.runtimeTimeoutMs, "runtime bridge", "Is the project running? Launch it (godot_run_project or dbg_launch) with the Breakpoint MCP plugin enabled — it auto-registers the runtime autoload.");
+    const lsp = new LspClient(config.lspHost, config.lspPort, config.projectUri, config.lspTimeoutMs);
+    // D4 C2: the C# semantic plane. OmniSharp is spawned over stdio (lazily, on the
+    // first cs_* call) against the C# project root — so a host without OmniSharp
+    // installed starts and runs the other planes unaffected.
+    const csLsp = new CsLspClient(new StdioChannel(config.csLspCmd, config.csLspArgs, config.csLspProjectPath, "C# LSP (OmniSharp)", "Is OmniSharp installed and on PATH (or set GODOT_CSLSP_CMD to its binary), and GODOT_CSHARP_PROJECT pointed at a restored C# project?"), config.csLspProjectUri, config.csLspTimeoutMs);
+    const dap = new DapClient(config.dapHost, config.dapPort, config.dapTimeoutMs);
+    // D4 C3: the C# debugging plane. netcoredbg is spawned over stdio (lazily, on
+    // the first cs_dbg_* call) — so a host without netcoredbg installed starts and
+    // runs every other plane unaffected.
+    const csDap = new CsDapClient(new StdioChannel(config.csDapCmd, config.csDapArgs, config.csDapProjectPath, "C# DAP (netcoredbg)", "Is netcoredbg installed and on PATH (or set GODOT_CSDAP_CMD to its binary), and GODOT_CSHARP_PROJECT pointed at a C# project?"), config.csDapTimeoutMs);
+    // D2: advertise the MCP task-execution model and hand the SDK a task store,
+    // so long jobs (export/import/headless script) support poll/await/cancel.
+    // D3: also advertise resources.subscribe so clients can subscribe to
+    // godot://… resources and receive notifications/resources/updated.
+    const server = new McpServer({ name: "breakpoint-mcp", version: "1.0.0" }, { capabilities: { ...TASK_CAPABILITIES, ...RESOURCE_CAPABILITIES }, taskStore });
+    // B1: enforce frozen output schemas on every structured tool. Must run before
+    // the register*Tools calls below — it wraps server.registerTool.
+    applyOutputSchemas(server);
+    // Plane B (headless CLI): works without the editor running.
+    registerCliTools(server, config);
+    // Plane A (live editor): requires the editor open with the Breakpoint MCP plugin.
+    registerEditorTools(server, bridge);
+    // Plane D (semantic): connects to Godot's GDScript language server (LSP, 6005).
+    registerLspTools(server, lsp, config);
+    // Plane D (C# semantic, D4 C2): drives OmniSharp over stdio for the cs_* tools.
+    registerCsLspTools(server, csLsp, config);
+    // Plane D (debugging): connects to Godot's Debug Adapter (DAP, 6006).
+    registerDapTools(server, dap, config);
+    // Plane D (C# debugging, D4 C3): drives netcoredbg over stdio for the cs_dbg_* tools.
+    registerCsDapTools(server, csDap, config);
+    // Plane C (runtime): connects to the in-game runtime autoload (9081).
+    registerRuntimeTools(server, runtime);
+    // Phase 4: managed run + captured console output (transparent print() logs).
+    const processes = registerProcessTools(server, config);
+    // Group K: host-side knowledge & search (project grep, symbol/usage index, idiom lookup).
+    registerKnowledgeTools(server, config);
+    // Group J: AI asset generation (delegated backend / connected client; degrades
+    // to a request spec when no backend is configured). Writes + imports via the bridge.
+    registerAssetGenTools(server, bridge, config);
+    // Group M: native multiplayer & backend scaffolding (mp_*). Pure authoring —
+    // undoable node ops (spawner/synchronizer/authority) + gated GDScript codegen
+    // (enet/webrtc peer, @rpc wiring, lobby). Hosts nothing; scaffolds everything.
+    registerNetcodeTools(server, bridge, config);
+    // Group M (second half): backend-SDK integration scaffolding (backend_* / *_scaffold).
+    // Detects the installed SDK (SilentWolf/Nakama/PlayFab/Photon) and generates gated
+    // GDScript against it; degrades cleanly when the SDK is absent or lacks the feature.
+    registerBackendTools(server, bridge, config);
+    // Phase 4: MCP resources (scene tree, editor state, runtime tree/log, ClassDB docs).
+    registerResources(server, bridge, runtime);
+    // D3: resource subscriptions — push notifications/resources/updated when a
+    // subscribed godot://… resource changes (editor selection / edited scene, or
+    // the running game's live SceneTree). Rapid changes are coalesced per-URI; the
+    // trailing window is overridable via BREAKPOINT_RESOURCE_COALESCE_MS.
+    const coalesceRaw = envCompat("BREAKPOINT_RESOURCE_COALESCE_MS", "CLAUDE_RESOURCE_COALESCE_MS");
+    const coalesceMs = coalesceRaw ? Number.parseInt(coalesceRaw, 10) : undefined;
+    registerResourceSubscriptions(server, bridge, runtime, undefined, { coalesceMs });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    log(`ready · godotBin=${config.godotBin} · project=${config.projectPath} · ` +
+        `bridge=${config.bridgeHost}:${config.bridgePort} · runtime=${config.runtimeHost}:${config.runtimePort} · ` +
+        `lsp=${config.lspHost}:${config.lspPort} · dap=${config.dapHost}:${config.dapPort}`);
+    const shutdown = () => {
+        bridge.close();
+        runtime.close();
+        lsp.close();
+        csLsp.close();
+        dap.close();
+        csDap.close();
+        processes.killAll();
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+}
+main().catch((err) => {
+    log("fatal:", err instanceof Error ? err.stack ?? err.message : String(err));
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/logger.js

@@ -0,0 +1,11 @@
+/**
+ * All diagnostic logging MUST go to stderr. stdout is reserved for the MCP
+ * stdio transport (JSON-RPC frames); writing anything else there corrupts it.
+ */
+export function log(...args) {
+    const line = args
+        .map((a) => (typeof a === "string" ? a : JSON.stringify(a)))
+        .join(" ");
+    process.stderr.write(`[breakpoint-mcp] ${line}\n`);
+}
+//# sourceMappingURL=logger.js.map