feat: better debug support

README.md

@@ -71,6 +71,7 @@ These options are resolved relative to the [workspace file](https://code.visuals
 - `vitest.configSearchPatternExclude`: [Glob pattern](https://code.visualstudio.com/docs/editor/glob-patterns) that should be ignored when this extension looks for config files. Note that this is applied to _config_ files, not test files inside configs. Default: `**/{node_modules,.*}/**`If the extension cannot find Vitest, please open an issue.
 - `vitest.nodeExecutable`: This extension spawns another process and will use this value as `execPath` argument.
 - `vitest.debuggerPort`: Port that the debugger will be attached to. By default uses 9229 or tries to find a free port if it's not available.
+- `vitest.debuggerAddress`: TCP/IP address of process to be debugged. Default: localhost
 
 ### Other Options
 

package.json

@@ -111,6 +111,11 @@
           "default": "**/{node_modules,.*}/**",
           "scope": "window"
         },
+        "vitest.debuggerAddress": {
+          "description": "TCP/IP address of process to be debugged. Default: localhost",
+          "type": "string",
+          "scope": "window"
+        },
         "vitest.debuggerPort": {
           "description": "Port that the debugger will be attached to. By default uses 9229 or tries to find a free port if it's not available.",
           "type": "string",

src/api.ts

@@ -173,10 +173,6 @@ export class VitestFolderAPI extends VitestReporter {
     await this.meta.rpc.cancelRun(this.id)
   }
 
-  getCoverageConfig() {
-    return this.meta.rpc.getCoverageConfig(this.id)
-  }
-
   waitForCoverageReport() {
     return this.meta.rpc.waitForCoverageReport(this.id)
   }
@@ -198,11 +194,11 @@ export class VitestFolderAPI extends VitestReporter {
   }
 
   stopInspect() {
-    return this.meta.rpc.stopInspect()
+    return this.meta.rpc.stopInspect(this.id)
   }
 
-  startInspect(port: number) {
-    return this.meta.rpc.startInspect(port)
+  startInspect(port: number, address?: string) {
+    return this.meta.rpc.startInspect(this.id, port, address)
   }
 }
 

src/api/rpc.ts

@@ -1,26 +1,32 @@
 import v8 from 'node:v8'
 import type { ChildProcess } from 'node:child_process'
 import { type BirpcReturn, createBirpc } from 'birpc'
-import type { File, ResolvedCoverageOptions, TaskResultPack, UserConsoleLog } from 'vitest'
+import type { File, TaskResultPack, UserConsoleLog } from 'vitest'
 
-export interface BirpcMethods {
-  getFiles: (id: string) => Promise<[project: string, file: string][]>
-  collectTests: (id: string, testFile: string[]) => Promise<void>
-  cancelRun: (id: string) => Promise<void>
-  runTests: (id: string, files?: string[], testNamePattern?: string) => Promise<void>
-  isTestFile: (file: string) => Promise<boolean>
+export interface VitestMethods {
+  getFiles: () => Promise<[project: string, file: string][]>
+  collectTests: (testFile: string[]) => Promise<void>
+  cancelRun: () => Promise<void>
+  runTests: (files?: string[], testNamePattern?: string) => Promise<void>
 
-  watchTests: (id: string, files?: string[], testNamePattern?: string) => Promise<void>
-  unwatchTests: (id: string) => Promise<void>
+  watchTests: (files?: string[], testNamePattern?: string) => void
+  unwatchTests: () => void
 
-  enableCoverage: (id: string) => void
-  disableCoverage: (id: string) => void
-  getCoverageConfig: (id: string) => Promise<ResolvedCoverageOptions>
-  waitForCoverageReport: (id: string) => Promise<string | null>
+  enableCoverage: () => void
+  disableCoverage: () => void
+  waitForCoverageReport: () => Promise<string | null>
 
-  startInspect: (port: number) => void
+  startInspect: (port: number, address?: string) => void
   stopInspect: () => void
+}
+
+type VitestPoolMethods = {
+  [K in keyof VitestMethods]: (id: string, ...args: Parameters<VitestMethods[K]>) => ReturnType<VitestMethods[K]>
+}
+
+export interface VitestPool extends VitestPoolMethods {
   close: () => void
+  isTestFile: (file: string) => boolean
 }
 
 export interface VitestEvents {
@@ -36,7 +42,7 @@ export type BirpcEvents = {
   [K in keyof VitestEvents]: (folder: string, ...args: Parameters<VitestEvents[K]>) => void
 }
 
-export type VitestRPC = BirpcReturn<BirpcMethods, BirpcEvents>
+export type VitestRPC = BirpcReturn<VitestPool, BirpcEvents>
 
 function createHandler<T extends (...args: any) => any>() {
   const handlers: T[] = []
@@ -95,7 +101,7 @@ function createRpcOptions() {
 export function createVitestRpc(vitest: ChildProcess) {
   const { events, handlers } = createRpcOptions()
 
-  const api = createBirpc<BirpcMethods, BirpcEvents>(
+  const api = createBirpc<VitestPool, BirpcEvents>(
     events,
     {
       timeout: -1,

src/config.ts

@@ -52,7 +52,8 @@ export function getConfig(workspaceFolder?: WorkspaceFolder) {
     configSearchPatternExclude,
     nodeExecutable: resolvePath(nodeExecutable),
     disableWorkspaceWarning: get<boolean>('disableWorkspaceWarning', false),
-    debuggerPort: get<number>('debuggerPort'),
+    debuggerPort: get<number>('debuggerPort') || undefined,
+    debuggerAddress: get<string>('debuggerAddress', undefined) || undefined,
   }
 }
 

src/debug/debugManager.ts

@@ -1,19 +1,16 @@
 import * as vscode from 'vscode'
-import type { TestRunner } from '../runner/runner'
+import getPort from 'get-port'
+import { getConfig } from '../config'
+import { log } from '../log'
 import type { VitestFolderAPI } from '../api'
-import { showVitestError } from '../utils'
-
-interface VitestDebugConfig {
-  request: vscode.TestRunRequest
-  token: vscode.CancellationToken
-  runner: TestRunner
-  api: VitestFolderAPI
-}
 
 export class TestDebugManager extends vscode.Disposable {
   private disposables: vscode.Disposable[] = []
   private sessions = new Set<vscode.DebugSession>()
-  private configurations = new Map<string, VitestDebugConfig>()
+  private port: number | undefined
+  private address: string | undefined
+
+  private static DEBUG_DEFAULT_PORT = 9229
 
   constructor() {
     super(() => {
@@ -22,59 +19,74 @@ export class TestDebugManager extends vscode.Disposable {
 
     this.disposables.push(
       vscode.debug.onDidStartDebugSession((session) => {
-        // the main attach session is called "Remote Process [0]"
-        // https://github.com/microsoft/vscode-js-debug/blob/dfceaf103ce0cb83b53f1c3d88c06b8b63cb17da/src/targets/node/nodeAttacher.ts#L89
-        // there are also other sessions that are spawned from the main session
-        // but they have different names (like workers are named [worker #id])
-        // I wonder how we could make it easier to make custom debug configurations here?
-        // All this logic exists only because when "retry" is clicked, the main debug session is
-        // not recreated, - instead it reattaches itself and this session is created again,
-        // so we need to track that to correctly restart the tests
-        if (!session.configuration.name.startsWith('Remote Process'))
-          return
-        const baseSession = this.getVitestSession(session)
-        if (!baseSession)
-          return
-        const sym = baseSession.configuration.__vitest as string
-        const config = this.configurations.get(sym)
-        if (!config)
+        if (!session.configuration.__vitest)
           return
-        this.sessions.add(baseSession)
-        const { request, runner, token } = config
-        runner.runTests(request, token).catch((err: any) => {
-          showVitestError('Failed to debug tests', err)
-        })
+        this.sessions.add(session)
       }),
       vscode.debug.onDidTerminateDebugSession((session) => {
         if (!session.configuration.__vitest)
           return
         this.sessions.delete(session)
-        const sym = session.configuration.__vitest as string
-        const config = this.configurations.get(sym)
-        if (!config)
-          return
-        const { api } = config
-        api.cancelRun()
-        api.stopInspect()
       }),
     )
   }
 
-  public configure(id: string, config: VitestDebugConfig) {
-    this.configurations.set(id, config)
+  public async enable(api: VitestFolderAPI) {
+    await this.stop()
+
+    const config = getConfig()
+    this.port ??= config.debuggerPort || await getPort({ port: TestDebugManager.DEBUG_DEFAULT_PORT })
+    this.address ??= config.debuggerAddress
+    api.startInspect(this.port)
   }
 
-  public async stop() {
-    await Promise.allSettled([...this.sessions].map(s => vscode.debug.stopDebugging(s)))
-    this.configurations.clear()
+  public async disable(api: VitestFolderAPI) {
+    await this.stop()
+    this.port = undefined
+    this.address = undefined
+    api.stopInspect()
   }
 
-  private getVitestSession(session: vscode.DebugSession): vscode.DebugSession | undefined {
-    if (session.configuration.__vitest)
-      return session
-    if (session.parentSession)
-      return this.getVitestSession(session.parentSession)
+  public start(folder: vscode.WorkspaceFolder) {
+    const config = getConfig(folder)
+
+    const debugConfig = {
+      type: 'pwa-node',
+      request: 'attach',
+      name: 'Debug Tests',
+      port: this.port,
+      address: this.address,
+      autoAttachChildProcesses: true,
+      skipFiles: config.debugExclude,
+      smartStep: true,
+      __vitest: true,
+      env: {
+        ...process.env,
+        VITEST_VSCODE: 'true',
+      },
+    }
+
+    log.info(`[DEBUG] Starting debugging on ${debugConfig.address || 'localhost'}:${debugConfig.port}`)
+
+    vscode.debug.startDebugging(
+      folder,
+      debugConfig,
+      { suppressDebugView: true },
+    ).then(
+      (fulfilled) => {
+        if (fulfilled)
+          log.info('[DEBUG] Debugging started')
+        else
+          log.error('[DEBUG] Debugging failed')
+      },
+      (err) => {
+        log.error('[DEBUG] Start debugging failed')
+        log.error(err.toString())
+      },
+    )
+  }
 
-    return undefined
+  public async stop() {
+    await Promise.allSettled([...this.sessions].map(s => vscode.debug.stopDebugging(s)))
   }
 }

src/extension.ts

@@ -66,6 +66,8 @@ class VitestExtension {
 
     const configFiles = vitest.filter(x => x.configFile && !x.workspaceFile)
 
+    // TODO: hard limit on the number of config files
+
     if (configFiles.length > 3 && configFiles.every(c => getConfig(c.folder).disableWorkspaceWarning !== true)) {
       vscode.window.showWarningMessage(
         `Vitest found ${configFiles.length} config files. For better performance, consider using a workspace configuration.`,
@@ -146,7 +148,7 @@ class VitestExtension {
           () => {},
           false,
           undefined,
-          true,
+          false, // disable continues debugging
         )
       }
       debugProfile.tag = api.tag