dap-mcp-server 0.1.5

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "dap-mcp-server",
+  "version": "0.1.5",
+  "description": "MCP server wrapping the Debug Adapter Protocol for AI-driven debugging",
+  "keywords": [
+    "LLM",
+    "MCP",
+    "DAP"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "ssh://git@forgejo.professioneit.com/ProfessioneIT/dap-mcp-server.git"
+  },
+  "license": "MIT",
+  "author": "Ivan Iraci",
+  "type": "module",
+  "main": "build/index.js",
+  "types": "./build/index.d.ts",
+  "bin": {
+    "dap-mcp-server": "build/index.js"
+  },
+  "directories": {
+    "doc": "docs"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "start": "node build/index.js",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "@vscode/debugprotocol": "^1.68.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  }
+}

package/src/adapters/builtin.ts

@@ -0,0 +1,47 @@
+/**
+ * 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.
+ */
+
+import { AdapterConfig } from "../dap/types.js";
+
+export const BUILTIN_ADAPTERS: AdapterConfig[] = [
+  {
+    type: "python",
+    runtime: "python3",
+    program: "-m",
+    args: ["debugpy.adapter"],
+    installHint: "pip install debugpy",
+  },
+  // node adapter removed — no reliable universal path to js-debug-dap.
+  // Configure via configure_adapter if needed.
+  {
+    type: "go",
+    program: "dlv",
+    args: ["dap"],
+    installHint: "go install github.com/go-delve/delve/cmd/dlv@latest",
+  },
+  {
+    type: "cppdbg",
+    program: "lldb-dap",
+    args: [],
+    installHint: "apt install lldb (Debian/Ubuntu) or brew install llvm (macOS)",
+  },
+];

package/src/adapters/detect.test.ts

@@ -0,0 +1,36 @@
+/**
+ * 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.
+ */
+
+import { describe, it, expect } from "vitest";
+import { checkAdapterAvailable } from "./detect.js";
+
+describe("checkAdapterAvailable", () => {
+  it("detects 'node' as available", async () => {
+    const result = await checkAdapterAvailable("node");
+    expect(result).toBe(true);
+  });
+
+  it("detects non-existent binary as unavailable", async () => {
+    const result = await checkAdapterAvailable("definitely-not-a-real-binary-xyz");
+    expect(result).toBe(false);
+  });
+});

package/src/adapters/detect.ts

@@ -0,0 +1,36 @@
+/**
+ * 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.
+ */
+
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+export async function checkAdapterAvailable(command: string): Promise<boolean> {
+  try {
+    const whichCmd = process.platform === "win32" ? "where" : "which";
+    await execFileAsync(whichCmd, [command]);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/adapters/registry.test.ts

@@ -0,0 +1,73 @@
+/**
+ * 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.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { AdapterRegistry } from "./registry.js";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+describe("AdapterRegistry", () => {
+  let tmpDir: string;
+  let registry: AdapterRegistry;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "dap-mcp-test-"));
+    registry = new AdapterRegistry(tmpDir, tmpDir);
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("returns built-in adapters", () => {
+    const adapters = registry.listAll();
+    expect(adapters.some((a) => a.type === "python")).toBe(true);
+    expect(adapters.some((a) => a.type === "go")).toBe(true);
+    // node adapter removed — no reliable universal path; configure via configure_adapter
+    expect(adapters.some((a) => a.type === "node")).toBe(false);
+  });
+
+  it("registers a custom adapter", () => {
+    registry.register({ type: "ruby", program: "/usr/bin/rdbg", args: ["--open", "--dap"] });
+    const ruby = registry.get("ruby");
+    expect(ruby).toBeDefined();
+    expect(ruby!.program).toBe("/usr/bin/rdbg");
+  });
+
+  it("project-local overrides built-in", () => {
+    registry.register({ type: "python", program: "/custom/debugpy" });
+    const python = registry.get("python");
+    expect(python!.program).toBe("/custom/debugpy");
+  });
+
+  it("saves and loads config from disk", async () => {
+    registry.register({ type: "ruby", program: "/usr/bin/rdbg" });
+    await registry.save("project");
+
+    const registry2 = new AdapterRegistry(tmpDir, tmpDir);
+    await registry2.load();
+    const ruby = registry2.get("ruby");
+    expect(ruby).toBeDefined();
+    expect(ruby!.program).toBe("/usr/bin/rdbg");
+  });
+});

package/src/adapters/registry.ts

@@ -0,0 +1,86 @@
+/**
+ * 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.
+ */
+
+import { AdapterConfig } from "../dap/types.js";
+import { BUILTIN_ADAPTERS } from "./builtin.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+export class AdapterRegistry {
+  private builtins: Map<string, AdapterConfig>;
+  private global: Map<string, AdapterConfig> = new Map();
+  private project: Map<string, AdapterConfig> = new Map();
+  private globalDir: string;
+  private projectDir: string;
+
+  constructor(globalDir: string, projectDir: string) {
+    this.globalDir = globalDir;
+    this.projectDir = projectDir;
+    this.builtins = new Map(BUILTIN_ADAPTERS.map((a) => [a.type, a]));
+  }
+
+  get(type: string): AdapterConfig | undefined {
+    return this.project.get(type) ?? this.global.get(type) ?? this.builtins.get(type);
+  }
+
+  register(config: AdapterConfig, scope: "global" | "project" = "project"): void {
+    const map = scope === "global" ? this.global : this.project;
+    map.set(config.type, config);
+  }
+
+  listAll(): Array<AdapterConfig & { source: "builtin" | "global" | "project" }> {
+    const result = new Map<string, AdapterConfig & { source: "builtin" | "global" | "project" }>();
+    for (const [type, config] of this.builtins) {
+      result.set(type, { ...config, source: "builtin" });
+    }
+    for (const [type, config] of this.global) {
+      result.set(type, { ...config, source: "global" });
+    }
+    for (const [type, config] of this.project) {
+      result.set(type, { ...config, source: "project" });
+    }
+    return Array.from(result.values());
+  }
+
+  async load(): Promise<void> {
+    this.global = await this.loadFile(path.join(this.globalDir, "adapters.json"));
+    this.project = await this.loadFile(path.join(this.projectDir, "adapters.json"));
+  }
+
+  async save(scope: "global" | "project"): Promise<void> {
+    const dir = scope === "global" ? this.globalDir : this.projectDir;
+    const map = scope === "global" ? this.global : this.project;
+    await fs.mkdir(dir, { recursive: true });
+    const data = Object.fromEntries(map);
+    await fs.writeFile(path.join(dir, "adapters.json"), JSON.stringify(data, null, 2));
+  }
+
+  private async loadFile(filePath: string): Promise<Map<string, AdapterConfig>> {
+    try {
+      const data = await fs.readFile(filePath, "utf-8");
+      const parsed = JSON.parse(data) as Record<string, AdapterConfig>;
+      return new Map(Object.entries(parsed));
+    } catch {
+      return new Map();
+    }
+  }
+}

package/src/dap/dap-client.test.ts

@@ -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.
+ */
+
+import { describe, it, expect, afterEach } from "vitest";
+import { DAPClient, DAPClientError } from "./dap-client.js";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+describe("DAPClient", () => {
+  let client: DAPClient | undefined;
+
+  afterEach(async () => {
+    if (client) {
+      try { await client.dispose(); } catch { /* ignore */ }
+      client = undefined;
+    }
+  });
+
+  it("spawns adapter and sends initialize request", async () => {
+    client = new DAPClient("node", path.join(__dirname, "../test-fixtures/mock-adapter.js"));
+    await client.spawn();
+    const response = await client.sendRequest("initialize", {
+      adapterID: "test",
+      linesStartAt1: true,
+      columnsStartAt1: true,
+      pathFormat: "path",
+    });
+    expect(response.success).toBe(true);
+    expect(response.command).toBe("initialize");
+  });
+
+  it("receives events from adapter", async () => {
+    client = new DAPClient("node", path.join(__dirname, "../test-fixtures/mock-adapter.js"));
+    await client.spawn();
+
+    const eventPromise = new Promise<any>((resolve) => {
+      client!.on("initialized", resolve);
+    });
+
+    await client.sendRequest("initialize", {
+      adapterID: "test",
+      linesStartAt1: true,
+      columnsStartAt1: true,
+      pathFormat: "path",
+    });
+
+    const event = await eventPromise;
+    expect(event.event).toBe("initialized");
+  });
+
+  it("rejects on adapter exit during request", async () => {
+    client = new DAPClient("node", path.join(__dirname, "../test-fixtures/crash-adapter.js"));
+    await client.spawn();
+    await expect(
+      client.sendRequest("initialize", { adapterID: "test" })
+    ).rejects.toThrow();
+  });
+
+  it("times out if adapter does not respond", async () => {
+    client = new DAPClient("node", path.join(__dirname, "../test-fixtures/silent-adapter.js"));
+    await client.spawn();
+    await expect(
+      client.sendRequest("initialize", { adapterID: "test" }, 500)
+    ).rejects.toThrow(/timeout/i);
+  });
+});

package/src/dap/dap-client.ts

@@ -0,0 +1,216 @@
+/**
+ * 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.
+ */
+
+import { spawn, ChildProcess } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { DebugProtocol } from "@vscode/debugprotocol";
+import { encodeMessage, MessageParser } from "./protocol.js";
+
+export class DAPClientError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "DAPClientError";
+  }
+}
+
+interface PendingRequest {
+  resolve: (response: DebugProtocol.Response) => void;
+  reject: (error: Error) => void;
+  timer?: ReturnType<typeof setTimeout>;
+}
+
+export class DAPClient extends EventEmitter {
+  private runtime: string;
+  private executable: string;
+  private args: string[];
+  private process?: ChildProcess;
+  private parser?: MessageParser;
+  private seq = 1;
+  private pending = new Map<number, PendingRequest>();
+  private stderrOutput: string[] = [];
+  private _exited = false;
+  private _exitCode?: number;
+
+  constructor(runtime: string, executable: string, args: string[] = []) {
+    super();
+    this.runtime = runtime;
+    this.executable = executable;
+    this.args = args;
+  }
+
+  async spawn(): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      const runtimeArgs = this.runtime
+        ? [this.executable, ...this.args]
+        : this.args;
+      const cmd = this.runtime || this.executable;
+
+      this.process = spawn(cmd, runtimeArgs, {
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+
+      this.parser = new MessageParser((msg) => this.handleMessage(msg));
+
+      this.process.stdout!.on("data", (data: Buffer) => {
+        this.parser!.feed(data);
+      });
+
+      this.process.stderr!.on("data", (data: Buffer) => {
+        this.stderrOutput.push(data.toString());
+      });
+
+      // Suppress EPIPE and other stream errors on stdin; the exit handler handles cleanup
+      this.process.stdin!.on("error", () => {
+        // ignore — exit event will reject pending requests
+      });
+
+      this.process.on("error", (err) => {
+        reject(new DAPClientError(`Failed to spawn adapter: ${err.message}`));
+      });
+
+      this.process.on("exit", (code, signal) => {
+        this._exited = true;
+        this._exitCode = code ?? undefined;
+        for (const [, req] of this.pending) {
+          if (req.timer) clearTimeout(req.timer);
+          req.reject(
+            new DAPClientError(
+              `Adapter exited (code=${code}, signal=${signal}). stderr: ${this.stderrOutput.join("")}`
+            )
+          );
+        }
+        this.pending.clear();
+        this.emit("exit", code, signal);
+      });
+
+      // Resolve once the process is spawned (use flag to prevent double-resolve)
+      let resolved = false;
+      this.process.stdout!.once("readable", () => {
+        if (!resolved) { resolved = true; resolve(); }
+      });
+      setTimeout(() => {
+        if (!resolved) { resolved = true; resolve(); }
+      }, 100);
+    });
+  }
+
+  async sendRequest(
+    command: string,
+    args?: Record<string, unknown>,
+    timeout = 10000
+  ): Promise<DebugProtocol.Response> {
+    if (this._exited) {
+      throw new DAPClientError(
+        `Adapter has exited (code=${this._exitCode}). stderr: ${this.stderrOutput.join("")}`
+      );
+    }
+    if (!this.process?.stdin?.writable) {
+      throw new DAPClientError("Adapter stdin is not writable");
+    }
+
+    const seq = this.seq++;
+    const request: DebugProtocol.Request = {
+      seq,
+      type: "request",
+      command,
+      arguments: args,
+    };
+
+    return new Promise<DebugProtocol.Response>((resolve, reject) => {
+      const pending: PendingRequest = { resolve, reject };
+      if (timeout > 0) {
+        pending.timer = setTimeout(() => {
+          this.pending.delete(seq);
+          reject(new DAPClientError(`Request '${command}' timeout after ${timeout}ms`));
+        }, timeout);
+      }
+      this.pending.set(seq, pending);
+      try {
+        this.process!.stdin!.write(encodeMessage(request), (err) => {
+          if (err) {
+            // Write failed (e.g. EPIPE); clean up and reject
+            const p = this.pending.get(seq);
+            if (p) {
+              if (p.timer) clearTimeout(p.timer);
+              this.pending.delete(seq);
+              p.reject(new DAPClientError(`Write to adapter failed: ${err.message}`));
+            }
+          }
+        });
+      } catch (err) {
+        this.pending.delete(seq);
+        if (pending.timer) clearTimeout(pending.timer);
+        reject(new DAPClientError(`Write to adapter failed: ${(err as Error).message}`));
+      }
+    });
+  }
+
+  private handleMessage(msg: DebugProtocol.ProtocolMessage): void {
+    if (msg.type === "response") {
+      const response = msg as DebugProtocol.Response;
+      const pending = this.pending.get(response.request_seq);
+      if (pending) {
+        if (pending.timer) clearTimeout(pending.timer);
+        this.pending.delete(response.request_seq);
+        if (response.success) {
+          pending.resolve(response);
+        } else {
+          pending.reject(
+            new DAPClientError(
+              `DAP error on '${response.command}': ${response.message || "unknown error"}`
+            )
+          );
+        }
+      }
+    } else if (msg.type === "event") {
+      const event = msg as DebugProtocol.Event;
+      this.emit(event.event, event);
+      this.emit("event", event);
+    }
+  }
+
+  get exited(): boolean {
+    return this._exited;
+  }
+
+  get stderr(): string {
+    return this.stderrOutput.join("");
+  }
+
+  async dispose(): Promise<void> {
+    if (this.process && !this._exited) {
+      this.process.stdin?.end();
+      this.process.kill("SIGTERM");
+      await new Promise<void>((resolve) => {
+        const timer = setTimeout(() => {
+          this.process?.kill("SIGKILL");
+          resolve();
+        }, 3000);
+        this.process!.on("exit", () => {
+          clearTimeout(timer);
+          resolve();
+        });
+      });
+    }
+    this.removeAllListeners();
+  }
+}