fix for windows debug support

packages/bun-debug-adapter-protocol/src/debugger/adapter.ts

@@ -2,12 +2,19 @@ import type { InspectorEventMap } from "../../../bun-inspector-protocol/src/insp
 import type { JSC } from "../../../bun-inspector-protocol/src/protocol";
 import type { DAP } from "../protocol";
 // @ts-ignore
-import type { ChildProcess } from "node:child_process";
-import { spawn } from "node:child_process";
+import { spawn, ChildProcess } from "node:child_process";
 import { EventEmitter } from "node:events";
 import { WebSocketInspector, remoteObjectToString } from "../../../bun-inspector-protocol/index";
-import { UnixSignal, randomUnixPath } from "./signal";
+import { randomUnixPath, UnixSignal, WebSocketSignal } from "./signal";
 import { Location, SourceMap } from "./sourcemap";
+import { createServer, AddressInfo } from "node:net";
+
+export function getAvailablePort(): number {
+  const server = createServer().listen(0);
+  const port = (server.address() as AddressInfo).port;
+  server.close();
+  return port;
+}
 
 const capabilities: DAP.Capabilities = {
   supportsConfigurationDoneRequest: true,
@@ -215,6 +222,7 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
   #variables: Map<number, Variable>;
   #initialized?: InitializeRequest;
   #options?: DebuggerOptions;
+  #signal?: WebSocketSignal;
 
   constructor(url?: string | URL) {
     super();
@@ -489,36 +497,93 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
           ...env,
         };
 
-    const url = `ws+unix://${randomUnixPath()}`;
-    const signal = new UnixSignal();
+    if (process.platform !== "win32") {
+      // we're on unix
+      const url = `ws+unix://${randomUnixPath()}`;
+      const signal = new UnixSignal();
 
-    signal.on("Signal.received", () => {
-      this.#attach({ url });
-    });
+      signal.on("Signal.received", () => {
+        this.#attach({ url });
+      });
 
-    this.once("Adapter.terminated", () => {
-      signal.close();
-    });
+      this.once("Adapter.terminated", () => {
+        signal.close();
+      });
 
-    const query = stopOnEntry ? "break=1" : "wait=1";
-    processEnv["BUN_INSPECT"] = `${url}?${query}`;
-    processEnv["BUN_INSPECT_NOTIFY"] = signal.url;
+      const query = stopOnEntry ? "break=1" : "wait=1";
+      processEnv["BUN_INSPECT"] = `${url}?${query}`;
+      processEnv["BUN_INSPECT_NOTIFY"] = signal.url;
+
+      // This is probably not correct, but it's the best we can do for now.
+      processEnv["FORCE_COLOR"] = "1";
+      processEnv["BUN_QUIET_DEBUG_LOGS"] = "1";
+      processEnv["BUN_DEBUG_QUIET_LOGS"] = "1";
+
+      const started = await this.#spawn({
+        command: runtime,
+        args: processArgs,
+        env: processEnv,
+        cwd,
+        isDebugee: true,
+      });
 
-    // This is probably not correct, but it's the best we can do for now.
-    processEnv["FORCE_COLOR"] = "1";
-    processEnv["BUN_QUIET_DEBUG_LOGS"] = "1";
-    processEnv["BUN_DEBUG_QUIET_LOGS"] = "1";
+      if (!started) {
+        throw new Error("Program could not be started.");
+      }
+    } else {
+      // we're on windows
+      // Create WebSocketSignal
+      const signalUrl = `ws://localhost:${getAvailablePort()}`;
+      this.#signal = new WebSocketSignal(signalUrl);
 
-    const started = await this.#spawn({
-      command: runtime,
-      args: processArgs,
-      env: processEnv,
-      cwd,
-      isDebugee: true,
-    });
+      // Set BUN_INSPECT_NOTIFY to signal's URL
+      processEnv["BUN_INSPECT_NOTIFY"] = this.#signal.url;
+
+      // Set BUN_INSPECT to the debugger's inspector URL with ?wait=1
+      processEnv["BUN_INSPECT"] = `${this.#inspector.url}?wait=1`;
+
+      // Spawn the process
+      const child = spawn(runtime, processArgs, {
+        cwd,
+        env: processEnv,
+        stdio: ["ignore", "pipe", "pipe"],
+      });
 
-    if (!started) {
-      throw new Error("Program could not be started.");
+      this.#process = child;
+
+      // Attach event listeners for the process
+      child.stderr?.setEncoding("utf-8");
+      child.stderr?.on("data", data => this.emit("Process.stderr", data));
+      child.on("exit", (code, signal) => {
+        this.emit("Process.exited", code ?? signal ?? null, signal ?? null);
+      });
+
+      this.emit("Process.spawned", child);
+
+      // Wait for the signal from the debuggee
+      await this.#signal.ready;
+      await new Promise<void>((resolve, reject) => {
+        this.#signal!.once("Signal.received", () => {
+          resolve();
+        });
+        this.#signal!.once("Signal.error", error => {
+          reject(error);
+        });
+      });
+
+      // Connect the debugger to the debuggee
+      const connected = await this.#inspector.start();
+      if (!connected) {
+        this.terminate();
+      }
+
+      // Additional setup if needed
+      this.emit("Adapter.process", {
+        name: `${runtime} ${processArgs.join(" ")}`,
+        systemProcessId: child.pid,
+        isLocalProcess: true,
+        startMethod: "launch",
+      });
     }
   }
 
@@ -2107,7 +2172,7 @@ export class DebugAdapter extends EventEmitter<DebugAdapterEventMap> implements
 
   close(): void {
     this.#process?.kill();
-    // this.#signal?.close();
+    if (process.platform === "win32") this.#signal?.close();
     this.#inspector.close();
     this.#reset();
   }

packages/bun-debug-adapter-protocol/src/debugger/signal.ts

@@ -1,4 +1,5 @@
 import { EventEmitter } from "node:events";
+import { WebSocketServer } from "ws";
 import type { Server } from "node:net";
 import { createServer } from "node:net";
 import { tmpdir } from "node:os";
@@ -85,3 +86,76 @@ function parseUnixPath(path: string | URL): string {
     throw new Error(`Invalid UNIX path: ${path}`);
   }
 }
+
+export type WebSocketSignalEventMap = {
+  "Signal.listening": [string];
+  "Signal.error": [Error];
+  "Signal.received": [string];
+  "Signal.closed": [];
+};
+
+/**
+ * Starts a server that listens for signals over a WebSocket.
+ */
+export class WebSocketSignal extends EventEmitter<WebSocketSignalEventMap> {
+  #url: string;
+  #server: WebSocketServer;
+  #ready: Promise<void>;
+
+  constructor(url: string) {
+    super();
+    this.#url = url;
+    const port = getPortFromUrl(url);
+    this.#server = new WebSocketServer({ port });
+
+    this.#server.on("listening", () => this.emit("Signal.listening", this.#url));
+    this.#server.on("error", error => this.emit("Signal.error", error));
+    this.#server.on("close", () => this.emit("Signal.closed"));
+    this.#server.on("connection", socket => {
+      socket.on("message", data => {
+        this.emit("Signal.received", data.toString());
+      });
+    });
+    this.#ready = new Promise((resolve, reject) => {
+      this.#server.on("listening", resolve);
+      this.#server.on("error", reject);
+    });
+  }
+
+  emit<E extends keyof WebSocketSignalEventMap>(event: E, ...args: WebSocketSignalEventMap[E]): boolean {
+    if (isDebug) {
+      console.log(event, ...args);
+    }
+    return super.emit(event, ...args);
+  }
+
+  /**
+   * The WebSocket URL.
+   */
+  get url(): string {
+    return this.#url;
+  }
+
+  /**
+   * Resolves when the server is listening or rejects if an error occurs.
+   */
+  get ready(): Promise<void> {
+    return this.#ready;
+  }
+
+  /**
+   * Closes the server.
+   */
+  close(): void {
+    this.#server.close();
+  }
+}
+
+function getPortFromUrl(url: string): number {
+  try {
+    const parsedUrl = new URL(url);
+    return parseInt(parsedUrl.port, 10) || 0;
+  } catch {
+    throw new Error(`Invalid WebSocket URL: ${url}`);
+  }
+}

packages/bun-vscode/example/hello.js

@@ -1,8 +1,16 @@
+// @bun
 console.log("HELLO");
+console.log(process.argv0);
 console.log("HELLO 2");
 console.log("HELLO 3");
 a();
 
 function a() {
   console.log("HELLO 4");
 }
+
+let i = 0;
+while (true) {
+  console.log(i);
+  i++;
+}

packages/bun-vscode/scripts/build.mjs

@@ -9,7 +9,7 @@ buildSync({
   entryPoints: ["src/extension.ts", "src/web-extension.ts"],
   outdir: "dist",
   bundle: true,
-  external: ["vscode"],
+  external: ["vscode", "ws"],
   platform: "node",
   format: "cjs",
   // The following settings are required to allow for extension debugging

packages/bun-vscode/src/features/debug.ts

@@ -2,7 +2,7 @@ import { DebugSession } from "@vscode/debugadapter";
 import { tmpdir } from "node:os";
 import * as vscode from "vscode";
 import type { DAP } from "../../../bun-debug-adapter-protocol";
-import { DebugAdapter, UnixSignal } from "../../../bun-debug-adapter-protocol";
+import { DebugAdapter, getAvailablePort, WebSocketSignal, UnixSignal } from "../../../bun-debug-adapter-protocol";
 
 export const DEBUG_CONFIGURATION: vscode.DebugConfiguration = {
   type: "bun",
@@ -176,7 +176,8 @@ class FileDebugSession extends DebugSession {
   constructor(sessionId?: string) {
     super();
     const uniqueId = sessionId ?? Math.random().toString(36).slice(2);
-    const url = `ws+unix://${tmpdir()}/${uniqueId}.sock`;
+    const url =
+      process.platform === "win32" ? `ws://localhost:${getAvailablePort()}` : `ws+unix://${tmpdir()}/${uniqueId}.sock`;
 
     this.adapter = new DebugAdapter(url);
     this.adapter.on("Adapter.response", response => this.sendResponse(response));
@@ -204,11 +205,16 @@ class FileDebugSession extends DebugSession {
 }
 
 class TerminalDebugSession extends FileDebugSession {
-  readonly signal: UnixSignal;
+  readonly signal: WebSocketSignal | UnixSignal;
 
   constructor() {
     super();
-    this.signal = new UnixSignal();
+    if (process.platform === "win32") {
+      const signalUrl = `ws://localhost:${getAvailablePort()}`;
+      this.signal = new WebSocketSignal(signalUrl);
+    } else {
+      this.signal = new UnixSignal();
+    }
     this.signal.on("Signal.received", () => {
       vscode.debug.startDebugging(undefined, {
         ...ATTACH_CONFIGURATION,

src/js/internal/debugger.ts

@@ -28,11 +28,21 @@ export default function (
     Bun.write(Bun.stderr, dim("--------------------- Bun Inspector ---------------------") + reset() + "\n");
   }
 
-  const unix = process.env["BUN_INSPECT_NOTIFY"];
-  if (unix) {
-    const { protocol, pathname } = parseUrl(unix);
-    if (protocol === "unix:") {
-      notify(pathname);
+  if (process.platform === "win32") {
+    const notifyUrl = process.env["BUN_INSPECT_NOTIFY"];
+    if (notifyUrl) {
+      const { protocol } = new URL(notifyUrl);
+      if (protocol === "ws:" || protocol === "wss:") {
+        notifyWebSocket(notifyUrl);
+      }
+    }
+  } else {
+    const unix = process.env["BUN_INSPECT_NOTIFY"];
+    if (unix) {
+      const { protocol, pathname } = parseUrl(unix);
+      if (protocol === "unix:") {
+        notify(pathname);
+      }
     }
   }
 }
@@ -73,7 +83,7 @@ class Debugger {
   #listen(): void {
     const { protocol, hostname, port, pathname } = this.#url;
 
-    if (protocol === "ws:" || protocol === "ws+tcp:") {
+    if (protocol === "ws:" || protocol === "wss:" || protocol === "ws+tcp:") {
       const server = Bun.serve({
         hostname,
         port,
@@ -94,7 +104,7 @@ class Debugger {
       return;
     }
 
-    throw new TypeError(`Unsupported protocol: '${protocol}' (expected 'ws:', 'ws+unix:', or 'unix:')`);
+    throw new TypeError(`Unsupported protocol: '${protocol}' (expected 'ws:', 'ws+unix:', or 'wss:')`);
   }
 
   get #websocket(): WebSocketHandler<Connection> {
@@ -321,6 +331,18 @@ function reset(): string {
   return "";
 }
 
+function notifyWebSocket(url: string): void {
+  const ws = new WebSocket(url);
+  ws.onopen = () => {
+    ws.send("1");
+    ws.close();
+  };
+  ws.onerror = error => {
+    // Handle error if needed
+    console.error("WebSocket error:", error);
+  };
+}
+
 function notify(unix: string): void {
   Bun.connect({
     unix,