dap-mcp-server 0.1.10 → 0.1.12

package/src/session/inspect.ts

@@ -0,0 +1,160 @@
+/**
+ * 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 { AdapterRegistry } from "../adapters/registry.js";
+import { SessionManager } from "./session-manager.js";
+import { DebugSession } from "./session.js";
+import { AdapterConfig } from "../dap/types.js";
+
+export interface InspectOptions {
+  adapter: string;
+  program: string;
+  args?: string[];
+  cwd?: string;
+  env?: Record<string, string>;
+  at: {
+    file: string;
+    line: number;
+    condition?: string;
+    hitCondition?: string;
+  };
+  expressions?: string[];
+  timeout?: number;
+  adapterConfig?: AdapterConfig;
+}
+
+export interface InspectValueResult {
+  result?: string;
+  type?: string;
+  error?: string;
+}
+
+export interface InspectResult {
+  hit: boolean;
+  reason?: string;
+  location?: { file: string; line: number; functionName?: string; column?: number };
+  values?: Record<string, InspectValueResult>;
+  output?: string[];
+  status?: string;
+}
+
+/**
+ * Launch a program, run until it hits the given breakpoint, evaluate a set of
+ * expressions in that frame, and disconnect. Collapses a multi-call workflow
+ * into a single operation suitable for "what is X at line N?" debugging.
+ */
+export async function runDebugInspect(
+  registry: AdapterRegistry,
+  sessions: SessionManager,
+  opts: InspectOptions
+): Promise<InspectResult> {
+  const config = opts.adapterConfig ?? registry.get(opts.adapter);
+  if (!config) {
+    throw new Error(
+      `Adapter '${opts.adapter}' not found. Use list_adapters to see available adapters or configure_adapter to register one.`
+    );
+  }
+
+  const id = sessions.generateId();
+  const session = new DebugSession(id, config);
+  sessions.add(session);
+
+  try {
+    await session.initialize();
+
+    const launchArgs: Record<string, unknown> = {
+      ...config.launchDefaults,
+      program: opts.program,
+      stopOnEntry: false,
+    };
+    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, [
+      {
+        line: opts.at.line,
+        condition: opts.at.condition,
+        hitCondition: opts.at.hitCondition,
+      },
+    ]);
+
+    await session.configurationDone();
+    await launchPromise;
+
+    const waitMs = opts.timeout ?? 30000;
+    try {
+      await session.waitForStopped(waitMs);
+    } catch {
+      const { output } = session.getOutput();
+      return {
+        hit: false,
+        status: session.state,
+        output: output.map((e) => e.text),
+      };
+    }
+
+    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, topFrameId);
+          values[expr] = { result: r.result, type: r.type };
+        } catch (err) {
+          values[expr] = { error: err instanceof Error ? err.message : String(err) };
+        }
+      }
+    }
+
+    return {
+      hit: true,
+      reason: state.reason,
+      location: state.location,
+      values: opts.expressions && opts.expressions.length > 0 ? values : undefined,
+      output: state.output,
+      status: "stopped",
+    };
+  } finally {
+    sessions.remove(session.id);
+    try {
+      await session.disconnect();
+    } catch {
+      /* best-effort cleanup */
+    }
+  }
+}

package/src/session/run.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 { runDebugRun } from "./run.js";
+import { AdapterRegistry } from "../adapters/registry.js";
+import { SessionManager } from "./session-manager.js";
+import path from "node:path";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const MOCK_ADAPTER = path.join(__dirname, "../test-fixtures/mock-adapter.js");
+
+function freshSetup() {
+  return {
+    registry: new AdapterRegistry(
+      path.join(os.tmpdir(), `dap-test-${Date.now()}-${Math.random()}-global`),
+      path.join(os.tmpdir(), `dap-test-${Date.now()}-${Math.random()}-project`)
+    ),
+    sessions: new SessionManager(),
+  };
+}
+
+describe("runDebugRun", () => {
+  it("runs a program to completion and returns its output", async () => {
+    const { registry, sessions } = freshSetup();
+    const result = await runDebugRun(registry, sessions, {
+      adapter: "mock",
+      program: "/test/app.py",
+      timeout: 5000,
+      adapterConfig: {
+        type: "mock",
+        runtime: "node",
+        program: MOCK_ADAPTER,
+      },
+    });
+
+    expect(result.terminated).toBe(true);
+    expect(result.status).toBe("terminated");
+    expect(result.output.some((s) => s.includes("Program started"))).toBe(true);
+    expect(result.output.some((s) => s.includes("Program completed"))).toBe(true);
+    expect(sessions.listAll()).toHaveLength(0);
+  });
+
+  it("rejects when adapter is unknown and no inline config provided", async () => {
+    const { registry, sessions } = freshSetup();
+    await expect(
+      runDebugRun(registry, sessions, {
+        adapter: "nonexistent",
+        program: "/test/app.py",
+      })
+    ).rejects.toThrow(/not found/);
+  });
+});

package/src/session/run.ts

@@ -0,0 +1,144 @@
+/**
+ * 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 { AdapterRegistry } from "../adapters/registry.js";
+import { SessionManager } from "./session-manager.js";
+import { DebugSession } from "./session.js";
+import { AdapterConfig } from "../dap/types.js";
+
+export interface RunOptions {
+  adapter: string;
+  program: string;
+  args?: string[];
+  cwd?: string;
+  env?: Record<string, string>;
+  /** Optional logpoints — break with logMessage emits formatted output without pausing. */
+  logpoints?: Array<{ file: string; line: number; logMessage: string }>;
+  /** Total wall-clock timeout for the whole run (default: 60_000ms). */
+  timeout?: number;
+  adapterConfig?: AdapterConfig;
+}
+
+export interface RunResult {
+  terminated: boolean;
+  output: string[];
+  status: string;
+}
+
+/**
+ * Launch a program with no stops, let it run to completion, and return the
+ * collected output. Use for "what does this script actually do / print / crash with?"
+ * cases where you don't need to inspect intermediate state. Pair with logpoints
+ * for printf-style debugging.
+ */
+export async function runDebugRun(
+  registry: AdapterRegistry,
+  sessions: SessionManager,
+  opts: RunOptions
+): Promise<RunResult> {
+  const config = opts.adapterConfig ?? registry.get(opts.adapter);
+  if (!config) {
+    throw new Error(
+      `Adapter '${opts.adapter}' not found. Use list_adapters to see available adapters or configure_adapter to register one.`
+    );
+  }
+
+  const id = sessions.generateId();
+  const session = new DebugSession(id, config);
+  sessions.add(session);
+
+  const totalTimeout = opts.timeout ?? 60_000;
+  const deadline = Date.now() + totalTimeout;
+
+  try {
+    await session.initialize();
+
+    const launchArgs: Record<string, unknown> = {
+      ...config.launchDefaults,
+      program: opts.program,
+      stopOnEntry: false,
+    };
+    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 }>>();
+      for (const lp of opts.logpoints) {
+        const existing = byFile.get(lp.file) ?? [];
+        existing.push({ line: lp.line, logMessage: lp.logMessage });
+        byFile.set(lp.file, existing);
+      }
+      for (const [file, bps] of byFile) {
+        await session.setBreakpoints(file, bps);
+      }
+    }
+
+    await session.configurationDone();
+    await launchPromise;
+
+    // Loop: if the program stops unexpectedly (e.g. exception, surprise breakpoint),
+    // continue. Exit when the program terminates or the deadline passes.
+    while (session.state !== "terminated") {
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) break;
+
+      if (session.state === "stopped") {
+        await session.continueExecution();
+      }
+
+      try {
+        await Promise.race([
+          session.waitForTerminated(remaining),
+          session.waitForStopped(remaining),
+        ]);
+      } catch {
+        // Both rejected (timeout). Bail.
+        break;
+      }
+    }
+
+    const { output } = session.getOutput();
+    return {
+      terminated: session.state === "terminated",
+      output: output.map((e) => e.text),
+      status: session.state,
+    };
+  } finally {
+    sessions.remove(session.id);
+    try {
+      await session.disconnect();
+    } catch {
+      /* best-effort cleanup */
+    }
+  }
+}

package/src/session/session.test.ts

@@ -69,6 +69,48 @@ describe("DebugSession", () => {
     expect(output.output).toHaveLength(1);
     expect(output.output[0].text).toBe("hello world");
     expect(output.output[0].category).toBe("stdout");
+    expect(output.output[0].seq).toBe(1);
+    expect(output.nextSince).toBe(1);
+  });
+
+  it("returns only new entries when called with since", async () => {
+    session = new DebugSession("test-since", {
+      type: "mock",
+      runtime: "node",
+      program: MOCK_ADAPTER,
+    });
+    session.addOutput("stdout", "line 1");
+    session.addOutput("stdout", "line 2");
+    const first = session.getOutput();
+    expect(first.output).toHaveLength(2);
+    expect(first.nextSince).toBe(2);
+
+    session.addOutput("stdout", "line 3");
+    session.addOutput("stderr", "err 1");
+    const incremental = session.getOutput(undefined, false, first.nextSince);
+    expect(incremental.output.map((e) => e.text)).toEqual(["line 3", "err 1"]);
+    expect(incremental.nextSince).toBe(4);
+
+    // No new entries since the latest nextSince
+    const empty = session.getOutput(undefined, false, incremental.nextSince);
+    expect(empty.output).toHaveLength(0);
+    expect(empty.nextSince).toBe(4);
+  });
+
+  it("combines since with category filter", async () => {
+    session = new DebugSession("test-since-cat", {
+      type: "mock",
+      runtime: "node",
+      program: MOCK_ADAPTER,
+    });
+    session.addOutput("stdout", "out 1");
+    session.addOutput("stderr", "err 1");
+    session.addOutput("stdout", "out 2");
+    session.addOutput("stderr", "err 2");
+
+    const stderrOnly = session.getOutput("stderr", false, 1);
+    expect(stderrOnly.output.map((e) => e.text)).toEqual(["err 1", "err 2"]);
+    expect(stderrOnly.nextSince).toBe(4);
   });
 
   it("detects adapter crash", async () => {

package/src/session/session.ts

@@ -29,6 +29,7 @@ import {
   OutputEntry,
   BreakpointConfig,
   BreakpointResult,
+  Variable,
 } from "../dap/types.js";
 import { DebugProtocol } from "@vscode/debugprotocol";
 import path from "node:path";
@@ -42,6 +43,7 @@ export class DebugSession {
   private adapterConfig: AdapterConfig;
   private _state: SessionState = "idle";
   private outputBuffer = new RingBuffer<OutputEntry>(MAX_OUTPUT_LINES);
+  private nextOutputSeq = 1;
   private breakpointsMap = new Map<string, BreakpointConfig[]>();
   private capabilities: DebugProtocol.Capabilities = {};
   private stoppedThreadId?: number;
@@ -51,6 +53,7 @@ export class DebugSession {
   private launchMode: "launch" | "attach" = "launch";
   private stoppedResolvers: Array<(event: DebugProtocol.StoppedEvent) => void> = [];
   private initializedResolvers: Array<() => void> = [];
+  private terminatedResolvers: Array<() => void> = [];
   private _initializedReceived = false;
 
   constructor(id: string, config: AdapterConfig) {
@@ -59,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);
@@ -69,9 +75,16 @@ export class DebugSession {
       if (this._state !== "terminated") {
         this._state = "terminated";
       }
+      this.resolveTerminatedWaiters();
     });
   }
 
+  private resolveTerminatedWaiters(): void {
+    const resolvers = this.terminatedResolvers;
+    this.terminatedResolvers = [];
+    for (const r of resolvers) r();
+  }
+
   get state(): SessionState {
     return this._state;
   }
@@ -94,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";
@@ -199,6 +217,29 @@ export class DebugSession {
     await this.client.sendRequest("pause", { threadId: tid });
   }
 
+  async waitForTerminated(timeout = DEFAULT_TIMEOUT): Promise<void> {
+    if (this._state === "terminated") return;
+    return new Promise<void>((resolve, reject) => {
+      let settled = false;
+      const wrapped = () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        const idx = this.terminatedResolvers.indexOf(wrapped);
+        if (idx !== -1) this.terminatedResolvers.splice(idx, 1);
+        resolve();
+      };
+      const timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        const idx = this.terminatedResolvers.indexOf(wrapped);
+        if (idx !== -1) this.terminatedResolvers.splice(idx, 1);
+        reject(new Error("timeout"));
+      }, timeout);
+      this.terminatedResolvers.push(wrapped);
+    });
+  }
+
   async waitForStopped(timeout = DEFAULT_TIMEOUT): Promise<DebugProtocol.StoppedEvent> {
     if (this._state === "stopped") {
       return {
@@ -251,17 +292,9 @@ export class DebugSession {
   async getVariables(
     variablesReference: number,
     depth = 1
-  ): Promise<
-    Array<{
-      name: string;
-      value: string;
-      type?: string;
-      hasChildren: boolean;
-      variablesReference: number;
-    }>
-  > {
+  ): Promise<Variable[]> {
     const response = await this.client.sendRequest("variables", { variablesReference });
-    const vars = ((response.body?.variables as DebugProtocol.Variable[]) || []).map((v) => ({
+    const vars: Variable[] = ((response.body?.variables as DebugProtocol.Variable[]) || []).map((v) => ({
       name: v.name,
       value: v.value,
       type: v.type,
@@ -271,8 +304,7 @@ export class DebugSession {
     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(", ")} }`;
+          v.children = await this.getVariables(v.variablesReference, depth - 1);
         }
       }
     }
@@ -345,16 +377,28 @@ export class DebugSession {
   }
 
   addOutput(category: string, text: string): void {
-    this.outputBuffer.push({ category, text, timestamp: new Date().toISOString() });
+    this.outputBuffer.push({
+      seq: this.nextOutputSeq++,
+      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();
+    clear = false,
+    since?: number
+  ): { output: OutputEntry[]; truncated: boolean; nextSince: number } {
+    const matches = (e: OutputEntry): boolean => {
+      if (category && e.category !== category) return false;
+      if (since !== undefined && e.seq <= since) return false;
+      return true;
+    };
+    const entries =
+      category !== undefined || since !== undefined
+        ? this.outputBuffer.getFiltered(matches)
+        : this.outputBuffer.getAll();
     const truncated = this.outputBuffer.truncated;
     if (clear) {
       if (category) {
@@ -363,7 +407,9 @@ export class DebugSession {
         this.outputBuffer.clear();
       }
     }
-    return { output: entries, truncated };
+    const lastInResult = entries.length > 0 ? entries[entries.length - 1].seq : undefined;
+    const nextSince = lastInResult ?? since ?? this.nextOutputSeq - 1;
+    return { output: entries, truncated, nextSince };
   }
 
   async disconnect(terminateDebuggee?: boolean): Promise<void> {
@@ -429,6 +475,7 @@ export class DebugSession {
       case "terminated":
       case "exited":
         this._state = "terminated";
+        this.resolveTerminatedWaiters();
         break;
     }
   }

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

@@ -52,6 +52,8 @@ function send(msg) {
 
 let seq = 1;
 let currentLine = 1;
+let breakpointCount = 0;
+let stopOnEntry = false;
 
 function handleMessage(msg) {
   if (msg.type !== "request") return;
@@ -62,6 +64,7 @@ function handleMessage(msg) {
       send({ seq: seq++, type: "event", event: "initialized", body: {} });
       break;
     case "setBreakpoints":
+      breakpointCount += (msg.arguments.breakpoints || []).length;
       send({ seq: seq++, type: "response", request_seq: msg.seq, command: "setBreakpoints", success: true,
         body: { breakpoints: (msg.arguments.breakpoints || []).map((bp, i) => ({ id: i+1, verified: true, line: bp.line })) } });
       break;
@@ -70,12 +73,24 @@ function handleMessage(msg) {
       break;
     case "configurationDone":
       send({ seq: seq++, type: "response", request_seq: msg.seq, command: "configurationDone", success: true, body: {} });
+      // Real-adapter behavior: after configurationDone, if launch was non-stopOnEntry
+      // and breakpoints were set, the program runs and hits the first breakpoint.
+      if (!stopOnEntry && breakpointCount > 0) {
+        setTimeout(() => { send({ seq: seq++, type: "event", event: "stopped", body: { reason: "breakpoint", threadId: 1, allThreadsStopped: true } }); }, 50);
+      } else if (!stopOnEntry && breakpointCount === 0) {
+        // No breakpoints, no stop-on-entry: program runs to completion and terminates.
+        setTimeout(() => {
+          send({ seq: seq++, type: "event", event: "output", body: { category: "stdout", output: "Program completed\n" } });
+          send({ seq: seq++, type: "event", event: "terminated", body: {} });
+        }, 50);
+      }
       break;
     case "launch":
       currentLine = 1;
+      stopOnEntry = !!msg.arguments.stopOnEntry;
       send({ seq: seq++, type: "response", request_seq: msg.seq, command: "launch", success: true, body: {} });
       send({ seq: seq++, type: "event", event: "output", body: { category: "stdout", output: "Program started\n" } });
-      if (msg.arguments.stopOnEntry) {
+      if (stopOnEntry) {
         setTimeout(() => { send({ seq: seq++, type: "event", event: "stopped", body: { reason: "entry", threadId: 1, allThreadsStopped: true } }); }, 50);
       }
       break;
@@ -105,6 +120,13 @@ function handleMessage(msg) {
             { name: "name", value: "'hello'", type: "str", variablesReference: 0 },
             { name: "data", value: "[1, 2, 3]", type: "list", variablesReference: 300 },
           ] } });
+      } else if (msg.arguments.variablesReference === 300) {
+        send({ seq: seq++, type: "response", request_seq: msg.seq, command: "variables", success: true,
+          body: { variables: [
+            { name: "0", value: "1", type: "int", variablesReference: 0 },
+            { name: "1", value: "2", type: "int", variablesReference: 0 },
+            { name: "2", value: "3", type: "int", variablesReference: 0 },
+          ] } });
       } else {
         send({ seq: seq++, type: "response", request_seq: msg.seq, command: "variables", success: true, body: { variables: [] } });
       }