Add DAP tracker and fix stopped-event replay timing

Two changes to debug the 'variables not auto-loading' issue:

1. Add a DebugAdapterTrackerFactory that logs every message between
   VS Code and the debug adapter in the GitHub Actions output channel.
   This will show the exact DAP flow when connecting and stepping.

2. Fix the stopped-event replay timing: buffer replay now triggers
   when the configurationDone *response* arrives from the runner
   (not when the request is sent), with a short delay to let VS Code
   finish processing the response before receiving the stopped event.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: rentziass

src/debugger/debugger.ts

@@ -1,6 +1,6 @@
 import * as vscode from "vscode";
 import {getSession} from "../auth/auth";
-import {log, logError} from "../log";
+import {log, logDebug, logError} from "../log";
 import {validateTunnelUrl} from "./tunnelUrl";
 import {WebSocketDapAdapter} from "./webSocketDapAdapter";
 
@@ -20,6 +20,11 @@ export function registerDebugger(context: vscode.ExtensionContext): void {
     vscode.debug.registerDebugAdapterDescriptorFactory(DEBUG_TYPE, new ActionsDebugAdapterFactory())
   );
 
+  // Register a tracker to log all DAP traffic for diagnostics.
+  context.subscriptions.push(
+    vscode.debug.registerDebugAdapterTrackerFactory(DEBUG_TYPE, new ActionsDebugTrackerFactory())
+  );
+
   // Register the connect command.
   context.subscriptions.push(
     vscode.commands.registerCommand("github-actions.debugger.connect", () => connectToDebugger())
@@ -113,3 +118,37 @@ class ActionsDebugAdapterFactory implements vscode.DebugAdapterDescriptorFactory
     return new vscode.DebugAdapterInlineImplementation(adapter);
   }
 }
+
+// ── Debug adapter tracker (diagnostics) ──────────────────────────────
+
+class ActionsDebugTrackerFactory implements vscode.DebugAdapterTrackerFactory {
+  createDebugAdapterTracker(): vscode.DebugAdapterTracker {
+    return {
+      onWillReceiveMessage(message: unknown) {
+        const m = message as Record<string, unknown>;
+        logDebug(`[tracker] VS Code → DA: ${String(m.type)}${m.command ? `:${String(m.command)}` : ""} (seq ${String(m.seq)})`);
+      },
+      onDidSendMessage(message: unknown) {
+        const m = message as Record<string, unknown>;
+        const body = m.body as Record<string, unknown> | undefined;
+        let detail = String(m.type);
+        if (m.command) {
+          detail += `:${String(m.command)}`;
+        }
+        if (m.event) {
+          detail += `:${String(m.event)}`;
+        }
+        if (m.event === "stopped" && body) {
+          detail += ` threadId=${String(body.threadId)} allThreadsStopped=${String(body.allThreadsStopped)}`;
+        }
+        logDebug(`[tracker] DA → VS Code: ${detail} (seq ${String(m.seq)})`);
+      },
+      onError(error: Error) {
+        logError(error, "[tracker] DAP error");
+      },
+      onExit(code: number | undefined, signal: string | undefined) {
+        log(`[tracker] DAP session exited: code=${String(code)} signal=${String(signal)}`);
+      }
+    };
+  }
+}

src/debugger/webSocketDapAdapter.ts

@@ -102,20 +102,6 @@ export class WebSocketDapAdapter implements vscode.DebugAdapter {
     const json = JSON.stringify(message);
     logDebug(`→ DAP: ${describeDapMessage(message)}`);
     this._ws.send(json);
-
-    // Detect configurationDone and replay any stopped events the runner
-    // sent before VS Code was ready to receive them.
-    const m = message as Record<string, unknown>;
-    if (m.command === "configurationDone" && m.type === "request") {
-      this._configurationDone = true;
-      if (this._pendingStoppedEvents.length > 0) {
-        logDebug(`Replaying ${this._pendingStoppedEvents.length} buffered stopped event(s)`);
-        for (const evt of this._pendingStoppedEvents) {
-          this._onDidSendMessage.fire(evt);
-        }
-        this._pendingStoppedEvents = [];
-      }
-    }
   }
 
   dispose(): void {
@@ -156,17 +142,35 @@ export class WebSocketDapAdapter implements vscode.DebugAdapter {
 
       logDebug(`← DAP: ${describeDapMessage(message)}`);
 
-      // Buffer stopped events that arrive before configurationDone — the
-      // runner re-sends the stopped event on connect (before the client
-      // finishes the DAP handshake) and VS Code silently drops them.
+      // Buffer stopped events that arrive before the configurationDone
+      // response — the runner re-sends the stopped event on connect
+      // (before the DAP handshake completes) and VS Code drops them.
       const m = message as Record<string, unknown>;
       if (m.type === "event" && m.event === "stopped" && !this._configurationDone) {
-        logDebug("Buffering stopped event (configurationDone not yet sent)");
+        logDebug("Buffering stopped event (configurationDone response not yet received)");
         this._pendingStoppedEvents.push(message);
         return;
       }
 
       this._onDidSendMessage.fire(message);
+
+      // When the configurationDone response arrives from the runner,
+      // replay any stopped events that were buffered during the
+      // handshake. We use a short delay so VS Code finishes processing
+      // the configurationDone response before receiving the event.
+      if (m.type === "response" && m.command === "configurationDone") {
+        this._configurationDone = true;
+        if (this._pendingStoppedEvents.length > 0) {
+          const events = this._pendingStoppedEvents;
+          this._pendingStoppedEvents = [];
+          logDebug(`Replaying ${events.length} buffered stopped event(s)`);
+          setTimeout(() => {
+            for (const evt of events) {
+              this._onDidSendMessage.fire(evt);
+            }
+          }, 50);
+        }
+      }
     });
 
     ws.on("close", (code: number, reason: Buffer) => {