dap-mcp-server 0.1.5

package/src/session/session-manager.test.ts

@@ -0,0 +1,74 @@
+/**
+ * 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 { SessionManager } from "./session-manager.js";
+
+describe("SessionManager", () => {
+  it("generates unique session IDs", () => {
+    const manager = new SessionManager();
+    const id1 = manager.generateId();
+    const id2 = manager.generateId();
+    expect(id1).not.toBe(id2);
+  });
+
+  it("stores and retrieves sessions by ID", () => {
+    const manager = new SessionManager();
+    const mockSession = { id: "test-1" } as any;
+    manager.add(mockSession);
+    expect(manager.get("test-1")).toBe(mockSession);
+  });
+
+  it("removes sessions", () => {
+    const manager = new SessionManager();
+    const mockSession = { id: "test-1" } as any;
+    manager.add(mockSession);
+    manager.remove("test-1");
+    expect(manager.get("test-1")).toBeUndefined();
+  });
+
+  it("resolves single session when no ID provided", () => {
+    const manager = new SessionManager();
+    const mockSession = { id: "test-1" } as any;
+    manager.add(mockSession);
+    expect(manager.resolve(undefined)).toBe(mockSession);
+  });
+
+  it("throws when resolving without ID and multiple sessions exist", () => {
+    const manager = new SessionManager();
+    manager.add({ id: "s1" } as any);
+    manager.add({ id: "s2" } as any);
+    expect(() => manager.resolve(undefined)).toThrow(/multiple/i);
+  });
+
+  it("throws when resolving non-existent session", () => {
+    const manager = new SessionManager();
+    expect(() => manager.resolve("nope")).toThrow(/not found/i);
+  });
+
+  it("lists all sessions", () => {
+    const manager = new SessionManager();
+    manager.add({ id: "s1" } as any);
+    manager.add({ id: "s2" } as any);
+    expect(manager.listAll()).toHaveLength(2);
+  });
+});

package/src/session/session-manager.ts

@@ -0,0 +1,67 @@
+/**
+ * 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 { DebugSession } from "./session.js";
+import { randomUUID } from "node:crypto";
+
+export class SessionManager {
+  private sessions = new Map<string, DebugSession>();
+
+  generateId(): string {
+    return randomUUID().slice(0, 8);
+  }
+
+  add(session: DebugSession): void {
+    this.sessions.set(session.id, session);
+  }
+
+  get(id: string): DebugSession | undefined {
+    return this.sessions.get(id);
+  }
+
+  remove(id: string): void {
+    this.sessions.delete(id);
+  }
+
+  resolve(sessionId: string | undefined): DebugSession {
+    if (sessionId) {
+      const session = this.sessions.get(sessionId);
+      if (!session) {
+        const available = Array.from(this.sessions.keys()).join(", ");
+        throw new Error(`Session '${sessionId}' not found. Available sessions: ${available || "none"}`);
+      }
+      return session;
+    }
+    if (this.sessions.size === 0) {
+      throw new Error("No active debug sessions. Use debug_launch or debug_attach first.");
+    }
+    if (this.sessions.size === 1) {
+      return this.sessions.values().next().value!;
+    }
+    const available = Array.from(this.sessions.keys()).join(", ");
+    throw new Error(`Multiple active sessions: ${available}. Specify sessionId.`);
+  }
+
+  listAll(): DebugSession[] {
+    return Array.from(this.sessions.values());
+  }
+}

package/src/session/session.test.ts

@@ -0,0 +1,84 @@
+/**
+ * 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 { DebugSession } from "./session.js";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const MOCK_ADAPTER = path.join(__dirname, "../test-fixtures/mock-adapter.js");
+
+describe("DebugSession", () => {
+  let session: DebugSession | undefined;
+
+  afterEach(async () => {
+    if (session) {
+      try { await session.disconnect(); } catch { /* ignore */ }
+      session = undefined;
+    }
+  });
+
+  it("initializes and tracks state", async () => {
+    session = new DebugSession("test-1", {
+      type: "mock",
+      runtime: "node",
+      program: MOCK_ADAPTER,
+    });
+    expect(session.state).toBe("idle");
+    await session.initialize();
+    expect(session.state).toBe("configuring");
+  });
+
+  it("has a unique session ID", () => {
+    session = new DebugSession("my-session", {
+      type: "mock",
+      runtime: "node",
+      program: MOCK_ADAPTER,
+    });
+    expect(session.id).toBe("my-session");
+  });
+
+  it("buffers output events", async () => {
+    session = new DebugSession("test-2", {
+      type: "mock",
+      runtime: "node",
+      program: MOCK_ADAPTER,
+    });
+    session.addOutput("stdout", "hello world");
+    const output = session.getOutput();
+    expect(output.output).toHaveLength(1);
+    expect(output.output[0].text).toBe("hello world");
+    expect(output.output[0].category).toBe("stdout");
+  });
+
+  it("detects adapter crash", async () => {
+    const crashAdapter = path.join(__dirname, "../test-fixtures/crash-adapter.js");
+    session = new DebugSession("test-crash", {
+      type: "mock",
+      runtime: "node",
+      program: crashAdapter,
+    });
+    await expect(session.initialize()).rejects.toThrow();
+    expect(session.state).toBe("terminated");
+  });
+});

package/src/session/session.ts

@@ -0,0 +1,435 @@
+/**
+ * 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 { DAPClient } from "../dap/dap-client.js";
+import { RingBuffer } from "../dap/ring-buffer.js";
+import {
+  SessionState,
+  StoppedState,
+  AdapterConfig,
+  OutputEntry,
+  BreakpointConfig,
+  BreakpointResult,
+} from "../dap/types.js";
+import { DebugProtocol } from "@vscode/debugprotocol";
+import path from "node:path";
+
+const MAX_OUTPUT_LINES = 10000;
+const DEFAULT_TIMEOUT = 30000;
+
+export class DebugSession {
+  readonly id: string;
+  private client: DAPClient;
+  private adapterConfig: AdapterConfig;
+  private _state: SessionState = "idle";
+  private outputBuffer = new RingBuffer<OutputEntry>(MAX_OUTPUT_LINES);
+  private breakpointsMap = new Map<string, BreakpointConfig[]>();
+  private capabilities: DebugProtocol.Capabilities = {};
+  private stoppedThreadId?: number;
+  private stoppedReason?: string;
+  private launchConfig?: Record<string, unknown>;
+  private attachConfig?: Record<string, unknown>;
+  private launchMode: "launch" | "attach" = "launch";
+  private stoppedResolvers: Array<(event: DebugProtocol.StoppedEvent) => void> = [];
+  private initializedResolvers: Array<() => void> = [];
+  private _initializedReceived = false;
+
+  constructor(id: string, config: AdapterConfig) {
+    this.id = id;
+    this.adapterConfig = config;
+    const runtime = config.runtime || "";
+    const program = config.program;
+    const args = config.args || [];
+    this.client = new DAPClient(runtime, program, args);
+
+    this.client.on("event", (event: DebugProtocol.Event) => {
+      this.handleEvent(event);
+    });
+
+    this.client.on("exit", () => {
+      if (this._state !== "terminated") {
+        this._state = "terminated";
+      }
+    });
+  }
+
+  get state(): SessionState {
+    return this._state;
+  }
+
+  async initialize(): Promise<DebugProtocol.Capabilities> {
+    try {
+      await this.client.spawn();
+    } catch (err) {
+      this._state = "terminated";
+      throw err;
+    }
+    try {
+      const response = await this.client.sendRequest("initialize", {
+        adapterID: this.adapterConfig.type,
+        clientID: "dap-mcp-server",
+        clientName: "DAP MCP Server",
+        linesStartAt1: true,
+        columnsStartAt1: true,
+        pathFormat: "path",
+      });
+      this.capabilities = response.body || {};
+      this._state = "configuring";
+      await this.waitForInitialized(10000);
+      return this.capabilities;
+    } catch (err) {
+      this._state = "terminated";
+      throw err;
+    }
+  }
+
+  async waitForInitialized(timeout = 10000): Promise<void> {
+    // If we already received the initialized event, resolve immediately
+    if (this._initializedReceived) return;
+    return new Promise<void>((resolve) => {
+      let settled = false;
+      const wrappedResolve = () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        const idx = this.initializedResolvers.indexOf(wrappedResolve);
+        if (idx !== -1) this.initializedResolvers.splice(idx, 1);
+        resolve();
+      };
+      const timer = setTimeout(() => {
+        // Don't reject — some adapters never send initialized; just continue
+        wrappedResolve();
+      }, timeout);
+      this.initializedResolvers.push(wrappedResolve);
+    });
+  }
+
+  async setBreakpoints(
+    filePath: string,
+    breakpoints: BreakpointConfig[]
+  ): Promise<BreakpointResult[]> {
+    const absPath = path.resolve(filePath);
+    this.breakpointsMap.set(absPath, breakpoints);
+    const response = await this.client.sendRequest("setBreakpoints", {
+      source: { path: absPath },
+      breakpoints: breakpoints.map((bp) => ({
+        line: bp.line,
+        condition: bp.condition,
+        hitCondition: bp.hitCondition,
+        logMessage: bp.logMessage,
+      })),
+    });
+    return ((response.body?.breakpoints as DebugProtocol.Breakpoint[]) || []).map((bp) => ({
+      id: bp.id,
+      verified: bp.verified ?? false,
+      line: bp.line ?? 0,
+      message: bp.message,
+    }));
+  }
+
+  async setExceptionBreakpoints(filters: string[]): Promise<void> {
+    await this.client.sendRequest("setExceptionBreakpoints", { filters });
+  }
+
+  async configurationDone(): Promise<void> {
+    if (this.capabilities.supportsConfigurationDoneRequest) {
+      await this.client.sendRequest("configurationDone");
+    }
+  }
+
+  async launch(config: Record<string, unknown>): Promise<void> {
+    this.launchConfig = config;
+    this.launchMode = "launch";
+    await this.client.sendRequest("launch", config);
+    this._state = "running";
+  }
+
+  async attach(config: Record<string, unknown>): Promise<void> {
+    this.attachConfig = config;
+    this.launchMode = "attach";
+    await this.client.sendRequest("attach", config);
+    this._state = "running";
+  }
+
+  async continueExecution(threadId?: number): Promise<void> {
+    const tid = threadId ?? this.stoppedThreadId ?? 1;
+    await this.client.sendRequest("continue", { threadId: tid });
+    this._state = "running";
+  }
+
+  async next(threadId?: number): Promise<void> {
+    const tid = threadId ?? this.stoppedThreadId ?? 1;
+    await this.client.sendRequest("next", { threadId: tid });
+    this._state = "running";
+  }
+
+  async stepIn(threadId?: number): Promise<void> {
+    const tid = threadId ?? this.stoppedThreadId ?? 1;
+    await this.client.sendRequest("stepIn", { threadId: tid });
+    this._state = "running";
+  }
+
+  async stepOut(threadId?: number): Promise<void> {
+    const tid = threadId ?? this.stoppedThreadId ?? 1;
+    await this.client.sendRequest("stepOut", { threadId: tid });
+    this._state = "running";
+  }
+
+  async pause(threadId?: number): Promise<void> {
+    const tid = threadId ?? this.stoppedThreadId ?? 1;
+    await this.client.sendRequest("pause", { threadId: tid });
+  }
+
+  async waitForStopped(timeout = DEFAULT_TIMEOUT): Promise<DebugProtocol.StoppedEvent> {
+    if (this._state === "stopped") {
+      return {
+        seq: 0,
+        type: "event",
+        event: "stopped",
+        body: { reason: this.stoppedReason || "unknown", threadId: this.stoppedThreadId },
+      } as DebugProtocol.StoppedEvent;
+    }
+    return new Promise<DebugProtocol.StoppedEvent>((resolve, reject) => {
+      let settled = false;
+      const wrappedResolve = (event: DebugProtocol.StoppedEvent) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        const idx = this.stoppedResolvers.indexOf(wrappedResolve);
+        if (idx !== -1) this.stoppedResolvers.splice(idx, 1);
+        resolve(event);
+      };
+      const timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        const idx = this.stoppedResolvers.indexOf(wrappedResolve);
+        if (idx !== -1) this.stoppedResolvers.splice(idx, 1);
+        reject(new Error("timeout"));
+      }, timeout);
+      this.stoppedResolvers.push(wrappedResolve);
+    });
+  }
+
+  async getThreads(): Promise<DebugProtocol.Thread[]> {
+    const response = await this.client.sendRequest("threads");
+    return (response.body?.threads as DebugProtocol.Thread[]) || [];
+  }
+
+  async getStackTrace(threadId: number, depth = 10): Promise<DebugProtocol.StackFrame[]> {
+    const response = await this.client.sendRequest("stackTrace", {
+      threadId,
+      startFrame: 0,
+      levels: depth,
+    });
+    return (response.body?.stackFrames as DebugProtocol.StackFrame[]) || [];
+  }
+
+  async getScopes(frameId: number): Promise<DebugProtocol.Scope[]> {
+    const response = await this.client.sendRequest("scopes", { frameId });
+    return (response.body?.scopes as DebugProtocol.Scope[]) || [];
+  }
+
+  async getVariables(
+    variablesReference: number,
+    depth = 1
+  ): Promise<
+    Array<{
+      name: string;
+      value: string;
+      type?: string;
+      hasChildren: boolean;
+      variablesReference: number;
+    }>
+  > {
+    const response = await this.client.sendRequest("variables", { variablesReference });
+    const vars = ((response.body?.variables as DebugProtocol.Variable[]) || []).map((v) => ({
+      name: v.name,
+      value: v.value,
+      type: v.type,
+      hasChildren: (v.variablesReference ?? 0) > 0,
+      variablesReference: v.variablesReference ?? 0,
+    }));
+    if (depth > 1) {
+      for (const v of vars) {
+        if (v.hasChildren) {
+          const children = await this.getVariables(v.variablesReference, depth - 1);
+          v.value = `${v.value} { ${children.map((c) => `${c.name}: ${c.value}`).join(", ")} }`;
+        }
+      }
+    }
+    return vars;
+  }
+
+  async evaluate(
+    expression: string,
+    frameId?: number,
+    context: "repl" | "watch" | "hover" = "repl"
+  ): Promise<{
+    result: string;
+    type?: string;
+    hasChildren: boolean;
+    variablesReference: number;
+  }> {
+    const args: Record<string, unknown> = { expression, context };
+    if (frameId !== undefined) args.frameId = frameId;
+    const response = await this.client.sendRequest("evaluate", args);
+    return {
+      result: (response.body?.result as string) ?? "",
+      type: response.body?.type as string | undefined,
+      hasChildren: ((response.body?.variablesReference as number) ?? 0) > 0,
+      variablesReference: (response.body?.variablesReference as number) ?? 0,
+    };
+  }
+
+  async collectState(
+    threadId?: number,
+    depth = 10,
+    variableDepth = 1
+  ): Promise<StoppedState> {
+    const tid = threadId ?? this.stoppedThreadId ?? 1;
+    const threads = await this.getThreads();
+    const frames = await this.getStackTrace(tid, depth);
+    const topFrame = frames[0];
+    const location = topFrame
+      ? {
+          file: topFrame.source?.path || topFrame.source?.name || "<unknown>",
+          line: topFrame.line,
+          column: topFrame.column,
+          functionName: topFrame.name,
+        }
+      : { file: "<unknown>", line: 0 };
+
+    const scopes: StoppedState["scopes"] = [];
+    if (topFrame) {
+      const rawScopes = await this.getScopes(topFrame.id);
+      for (const scope of rawScopes) {
+        const variables = await this.getVariables(scope.variablesReference, variableDepth);
+        scopes.push({ name: scope.name, variables });
+      }
+    }
+    const output = this.outputBuffer.getAll().map((e) => e.text);
+    return {
+      status: "stopped",
+      reason: this.stoppedReason || "unknown",
+      location,
+      threads: threads.map((t) => ({ id: t.id, name: t.name, stopped: t.id === tid })),
+      stackTrace: frames.map((f) => ({
+        id: f.id,
+        name: f.name,
+        file: f.source?.path || f.source?.name || "<unknown>",
+        line: f.line,
+        column: f.column,
+      })),
+      scopes,
+      output: output.length > 0 ? output : undefined,
+    };
+  }
+
+  addOutput(category: string, text: string): void {
+    this.outputBuffer.push({ category, text, timestamp: new Date().toISOString() });
+  }
+
+  getOutput(
+    category?: string,
+    clear = false
+  ): { output: OutputEntry[]; truncated: boolean } {
+    const entries = category
+      ? this.outputBuffer.getFiltered((e) => e.category === category)
+      : this.outputBuffer.getAll();
+    const truncated = this.outputBuffer.truncated;
+    if (clear) {
+      if (category) {
+        this.outputBuffer.removeMatching((e) => e.category === category);
+      } else {
+        this.outputBuffer.clear();
+      }
+    }
+    return { output: entries, truncated };
+  }
+
+  async disconnect(terminateDebuggee?: boolean): Promise<void> {
+    const terminate = terminateDebuggee ?? this.launchMode === "launch";
+    try {
+      await this.client.sendRequest("disconnect", { terminateDebuggee: terminate }, 5000);
+    } catch {
+      /* Ignore — adapter may have already exited */
+    }
+    this._state = "terminated";
+    await this.client.dispose();
+  }
+
+  getLaunchConfig(): Record<string, unknown> | undefined {
+    // Only returns a value for launched sessions, not attached
+    if (this.launchMode === "attach") return undefined;
+    return this.launchConfig;
+  }
+
+  getAttachConfig(): Record<string, unknown> | undefined {
+    return this.attachConfig;
+  }
+
+  getLaunchMode(): "launch" | "attach" {
+    return this.launchMode;
+  }
+
+  getAdapterConfig(): AdapterConfig {
+    return this.adapterConfig;
+  }
+
+  getBreakpoints(): Map<string, BreakpointConfig[]> {
+    return this.breakpointsMap;
+  }
+
+  private handleEvent(event: DebugProtocol.Event): void {
+    switch (event.event) {
+      case "initialized":
+        this._initializedReceived = true;
+        for (const resolve of this.initializedResolvers) resolve();
+        this.initializedResolvers = [];
+        break;
+      case "stopped":
+        this._state = "stopped";
+        this.stoppedThreadId = event.body?.threadId as number | undefined;
+        this.stoppedReason = event.body?.reason as string | undefined;
+        {
+          const resolvers = this.stoppedResolvers;
+          this.stoppedResolvers = [];
+          for (const resolve of resolvers) resolve(event as DebugProtocol.StoppedEvent);
+        }
+        break;
+      case "continued":
+        this._state = "running";
+        break;
+      case "output":
+        if (event.body?.output)
+          this.addOutput(
+            (event.body.category as string) || "console",
+            event.body.output as string
+          );
+        break;
+      case "terminated":
+      case "exited":
+        this._state = "terminated";
+        break;
+    }
+  }
+}

package/src/test-fixtures/crash-adapter.js

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ */
+
+process.exit(1);