dap-mcp-server 0.1.11 → 0.1.12

package/src/session/inspect.ts

@@ -89,8 +89,17 @@ export async function runDebugInspect(
     if (opts.args !== undefined) launchArgs.args = opts.args;
     if (opts.cwd !== undefined) launchArgs.cwd = opts.cwd;
     if (opts.env !== undefined) launchArgs.env = opts.env;
+    // delve: mirror cwd → dlvCwd so `go build` finds go.mod from the right dir.
+    if (config.type === "go" && opts.cwd !== undefined && launchArgs.dlvCwd === undefined) {
+      launchArgs.dlvCwd = opts.cwd;
+    }
 
     const launchPromise = session.launch(launchArgs);
+    // Suppress unhandled rejection: the real `await launchPromise` below will
+    // still throw if launch fails. Without this, an early launch rejection
+    // (e.g. adapter rejects the request) crashes the MCP server.
+    launchPromise.catch(() => { /* handled at await */ });
+    await session.waitForInitialized(10000);
 
     await session.setBreakpoints(opts.at.file, [
       {
@@ -118,9 +127,13 @@ export async function runDebugInspect(
     const state = await session.collectState();
     const values: Record<string, InspectValueResult> = {};
     if (opts.expressions && opts.expressions.length > 0) {
+      // Some adapters (vscode-js-debug) require a frameId to evaluate names
+      // bound in the current function's scope. Use the top frame's id when
+      // available so locals resolve correctly.
+      const topFrameId = state.stackTrace?.[0]?.id;
       for (const expr of opts.expressions) {
         try {
-          const r = await session.evaluate(expr);
+          const r = await session.evaluate(expr, topFrameId);
           values[expr] = { result: r.result, type: r.type };
         } catch (err) {
           values[expr] = { error: err instanceof Error ? err.message : String(err) };

package/src/session/run.ts

@@ -80,8 +80,16 @@ export async function runDebugRun(
     if (opts.args !== undefined) launchArgs.args = opts.args;
     if (opts.cwd !== undefined) launchArgs.cwd = opts.cwd;
     if (opts.env !== undefined) launchArgs.env = opts.env;
+    // delve: mirror cwd → dlvCwd so `go build` finds go.mod from the right dir.
+    if (config.type === "go" && opts.cwd !== undefined && launchArgs.dlvCwd === undefined) {
+      launchArgs.dlvCwd = opts.cwd;
+    }
 
     const launchPromise = session.launch(launchArgs);
+    // Suppress unhandled rejection: the real `await launchPromise` below will
+    // still throw if launch fails.
+    launchPromise.catch(() => { /* handled at await */ });
+    await session.waitForInitialized(10000);
 
     if (opts.logpoints && opts.logpoints.length > 0) {
       const byFile = new Map<string, Array<{ line: number; logMessage: string }>>();

package/src/session/session.ts

@@ -62,7 +62,10 @@ export class DebugSession {
     const runtime = config.runtime || "";
     const program = config.program;
     const args = config.args || [];
-    this.client = new DAPClient(runtime, program, args);
+    this.client = new DAPClient(runtime, program, args, {
+      transport: config.transport,
+      portMatcher: config.portMatcher,
+    });
 
     this.client.on("event", (event: DebugProtocol.Event) => {
       this.handleEvent(event);
@@ -104,7 +107,12 @@ export class DebugSession {
       });
       this.capabilities = response.body || {};
       this._state = "configuring";
-      await this.waitForInitialized(10000);
+      // Note: per DAP spec, the "initialized" event signals the adapter is
+      // ready for configuration (setBreakpoints, etc.). Different adapters
+      // emit it at different times: delve emits it immediately after the
+      // initialize response, but debugpy only emits it after `launch` is
+      // received. The orchestrator (server.ts) is responsible for waiting
+      // for it AFTER firing the launch/attach request — see waitForInitialized.
       return this.capabilities;
     } catch (err) {
       this._state = "terminated";

package/src/test-fixtures/tcp-mock-adapter.js

@@ -0,0 +1,87 @@
+/**
+ * Copyright (c) 2026 Ivan Iraci <ivan.iraci@professioneit.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+// TCP-mode mock DAP adapter for testing the TCP transport.
+// Opens a TCP listener on a random port, prints the listen address banner to
+// stdout (matching the regex "DAP server listening at: \S+:(\d+)"), accepts a
+// single client connection, and runs a tiny DAP server on it.
+
+import net from "node:net";
+
+const TWO_CRLF = "\r\n\r\n";
+
+const server = net.createServer((socket) => {
+  let buffer = Buffer.alloc(0);
+  let contentLength = -1;
+  let seq = 1;
+
+  const send = (msg) => {
+    const json = JSON.stringify(msg);
+    const header = `Content-Length: ${Buffer.byteLength(json)}${TWO_CRLF}`;
+    socket.write(header + json);
+  };
+
+  socket.on("data", (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+    while (true) {
+      if (contentLength === -1) {
+        const idx = buffer.indexOf(TWO_CRLF);
+        if (idx === -1) return;
+        const header = buffer.subarray(0, idx).toString();
+        const match = header.match(/Content-Length:\s*(\d+)/i);
+        if (!match) return;
+        contentLength = parseInt(match[1], 10);
+        buffer = buffer.subarray(idx + TWO_CRLF.length);
+      }
+      if (buffer.length < contentLength) return;
+      const body = buffer.subarray(0, contentLength).toString();
+      buffer = buffer.subarray(contentLength);
+      contentLength = -1;
+      const msg = JSON.parse(body);
+      if (msg.type === "request" && msg.command === "initialize") {
+        send({
+          seq: seq++,
+          type: "response",
+          request_seq: msg.seq,
+          command: msg.command,
+          success: true,
+          body: { supportsConfigurationDoneRequest: true },
+        });
+        send({ seq: seq++, type: "event", event: "initialized" });
+      } else if (msg.type === "request") {
+        send({
+          seq: seq++,
+          type: "response",
+          request_seq: msg.seq,
+          command: msg.command,
+          success: true,
+        });
+      }
+    }
+  });
+});
+
+server.listen(0, "127.0.0.1", () => {
+  const { address, port } = server.address();
+  // Print the listen banner in the same shape delve uses.
+  process.stdout.write(`DAP server listening at: ${address}:${port}\n`);
+});