feat: allow custom shell via vitest.shellType option (#490)

* feat: allow custom shell via `vitest.shellType` option

* feat: add "Show Shell Terminal" command

* feat: add vitest.nodeExecArgs to debugger

Author: sheremet-va

README.md

@@ -72,11 +72,19 @@ These options are resolved relative to the [workspace file](https://code.visuals
 
 - `vitest.rootConfig`: The path to your root config file. If you have several Vitest configs, consider using a [Vitest workspace](https://vitest.dev/guide/workspace).
 - `vitest.workspaceConfig`: The path to the [Vitest workspace](https://vitest.dev/guide/workspace) config file. You can only have a single workspace config per VSCode workspace.
-- `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/**,**/.*/**,*.d.ts}`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.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/**,**/.*/**,*.d.ts}`. If the extension cannot find Vitest, please open an issue.
+- `vitest.shellType`: The method the extension uses to spawn a long-running Vitest process. This is particularly useful if you are using a custom shell script to set up the environment. When using the `terminal` shell type, the websocket connection will be established. Can either be `terminal` or `child_process`. Default: `child process`.
+- `vitest.nodeExecutable`: The path to the Node.js executable. If not assigned, tries to find Node.js path via a PATH variable or a `which` command. This is applied only when `vitest.shellType` is `child_process` (the default).
+- `vitest.nodeExecArgs`: The arguments to pass to the Node.js executable. This is applied only when `vitest.shellType` is `child_process` (the default).
+- `vitest.terminalShellPath`: The path to the shell executable. This is applied only when `vitest.shellType` is `terminal`.
+- `vitest.terminalShellArgs`: The arguments to pass to the shell executable. This is applied only when `vitest.shellType` is `terminal`.
 - `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
 
+> [!NOTE]
+> The `vitest.nodeExecutable` and `vitest.nodeExecArgs` settings are used as `execPath` and `execArgv` when spawning a new `child_process`, and as `runtimeExecutable` and `runtimeArgs` when [debugging a test](https://github.com/microsoft/vscode-js-debug/blob/main/OPTIONS.md).
+> The `vitest.terminalShellPath` and `vitest.terminalShellArgs` settings are used as `shellPath` and `shellArgs` when creating a new [terminal](https://code.visualstudio.com/api/references/vscode-api#Terminal)
+
 ### Other Options
 
 - `vitest.filesWatcherInclude`: Glob pattern for the watcher that triggers a test rerun or collects changes. Default: `**/*`
@@ -104,3 +112,7 @@ You can change the behaviour of testing view by modifying `testing.openTesting`
 - `openExplorerOnTestStart`  will open the test tree view when tests starts
 
 This is a vscode's built-in option and will control every plugin.
+
+### I am using `vitest.shellType: terminal`, but I don't see it
+
+The extension uses a modified Vitest script that removes the reporter output. For this reason, the terminal is hidden by default. However, it might be useful to debug issues with the extension or Vitest itself - to open the terminal in the "Terminals" view you can use the "Vitest: Show Shell Terminal" command.

package.json

@@ -70,6 +70,11 @@
         "title": "Show Output Channel",
         "command": "vitest.openOutput",
         "category": "Vitest"
+      },
+      {
+        "title": "Show Shell Terminal",
+        "command": "vitest.showShellTerminal",
+        "category": "Vitest"
       }
     ],
     "menus": {
@@ -107,10 +112,15 @@
           "scope": "resource"
         },
         "vitest.nodeExecutable": {
-          "description": "The path to the Node.js executable. If not assigned, uses VSCode's Node.js instance.",
+          "markdownDescription": "The path to the Node.js executable. If not assigned, tries to find Node.js path via a PATH variable or a `which` command. This is applied only when `vitest.shellType` is `child_process` (the default).",
           "type": "string",
           "scope": "window"
         },
+        "vitest.nodeExecArgs": {
+          "description": "The arguments to pass to the Node.js executable. This is applied only when `vitest.shellType` is `child_process` (the default).",
+          "type": "array",
+          "scope": "resource"
+        },
         "vitest.workspaceConfig": {
           "markdownDescription": "The path to the Vitest [workspace configuration file](https://vitest.dev/guide/workspace). The extension supports only a single file per VSCode workspace.",
           "type": "string",
@@ -177,6 +187,26 @@
           ],
           "default": "info",
           "scope": "resource"
+        },
+        "vitest.shellType": {
+          "markdownDescription": "The method the extension uses to spawn a long-running Vitest process. This is particularly useful if you are using a custom shell script to set up the environment. When using the `terminal` shell type, the websocket connection will be established.",
+          "type": "string",
+          "enum": [
+            "terminal",
+            "child_process"
+          ],
+          "default": "child_process",
+          "scope": "resource"
+        },
+        "vitest.terminalShellPath": {
+          "markdownDescription": "The path to the shell executable. This is applied only when `vitest.shellType` is `terminal`.",
+          "type": "string",
+          "scope": "resource"
+        },
+        "vitest.terminalShellArgs": {
+          "markdownDescription": "The arguments to pass to the shell executable. This is applied only when `vitest.shellType` is `terminal`.",
+          "type": "array",
+          "scope": "resource"
         }
       }
     }

src/api.ts

@@ -1,45 +1,13 @@
-import type { ChildProcess } from 'node:child_process'
-import { fork } from 'node:child_process'
-import { pathToFileURL } from 'node:url'
-import { gte } from 'semver'
-import { dirname, normalize, relative } from 'pathe'
+import { normalize, relative } from 'pathe'
 import * as vscode from 'vscode'
 import { log } from './log'
-import { minimumNodeVersion, workerPath } from './constants'
-import { getConfig } from './config'
 import type { VitestEvents, VitestRPC } from './api/rpc'
-import { createVitestRpc } from './api/rpc'
-import type { WorkerEvent, WorkerRunnerOptions } from './worker/types'
 import type { VitestPackage } from './api/pkg'
-import { findNode, getNodeJsVersion, showVitestError } from './utils'
-import type { VitestProcess } from './process'
-
-export class VitestReporter {
-  constructor(
-    public readonly id: string,
-    protected handlers: ResolvedMeta['handlers'],
-  ) {}
-
-  onConsoleLog = this.createHandler('onConsoleLog')
-  onTaskUpdate = this.createHandler('onTaskUpdate')
-  onFinished = this.createHandler('onFinished')
-  onCollected = this.createHandler('onCollected')
-  onWatcherStart = this.createHandler('onWatcherStart')
-  onWatcherRerun = this.createHandler('onWatcherRerun')
-
-  clearListeners(name?: Exclude<keyof ResolvedMeta['handlers'], 'clearListeners' | 'removeListener'>) {
-    if (name)
-      this.handlers.removeListener(name, this.handlers[name])
-
-    this.handlers.clearListeners()
-  }
-
-  private createHandler<K extends Exclude<keyof ResolvedMeta['handlers'], 'clearListeners' | 'removeListener'>>(name: K) {
-    return (callback: VitestEvents[K]) => {
-      this.handlers[name](callback as any)
-    }
-  }
-}
+import { showVitestError } from './utils'
+import type { VitestProcess } from './api/types'
+import { createVitestTerminalProcess } from './api/terminal'
+import { getConfig } from './config'
+import { createVitestProcess } from './api/child_process'
 
 export class VitestAPI {
   private disposing = false
@@ -97,17 +65,21 @@ export class VitestAPI {
   }
 }
 
-export class VitestFolderAPI extends VitestReporter {
+export class VitestFolderAPI {
+  readonly id: string
   readonly tag: vscode.TestTag
   readonly workspaceFolder: vscode.WorkspaceFolder
 
+  private handlers: ResolvedMeta['handlers']
+
   constructor(
     private pkg: VitestPackage,
     private meta: ResolvedMeta,
   ) {
     const normalizedId = normalize(pkg.id)
-    super(normalizedId, meta.handlers)
+    this.id = normalizedId
     this.workspaceFolder = pkg.folder
+    this.handlers = meta.handlers
     this.tag = new vscode.TestTag(pkg.prefix)
   }
 
@@ -177,14 +149,17 @@ export class VitestFolderAPI extends VitestReporter {
       catch (err) {
         log.error('[API]', 'Failed to close Vitest RPC', err)
       }
-      const promise = new Promise<void>((resolve) => {
-        this.meta.process.once('exit', () => resolve())
+      const promise = new Promise<void>((resolve, reject) => {
+        const timer = setTimeout(() => {
+          reject(new Error('Vitest process did not exit in time'))
+        }, 5_000)
+        this.meta.process.once('exit', () => {
+          resolve()
+          clearTimeout(timer)
+        })
       })
       this.meta.process.close()
-      await Promise.all([
-        promise,
-        AbortSignal.timeout(5000),
-      ]).catch((err) => {
+      await promise.catch((err) => {
         log.error('[API]', 'Failed to close Vitest process', err)
       })
     }
@@ -213,6 +188,26 @@ export class VitestFolderAPI extends VitestReporter {
   async unwatchTests() {
     await this.meta.rpc.unwatchTests()
   }
+
+  onConsoleLog = this.createHandler('onConsoleLog')
+  onTaskUpdate = this.createHandler('onTaskUpdate')
+  onFinished = this.createHandler('onFinished')
+  onCollected = this.createHandler('onCollected')
+  onWatcherStart = this.createHandler('onWatcherStart')
+  onWatcherRerun = this.createHandler('onWatcherRerun')
+
+  clearListeners(name?: Exclude<keyof ResolvedMeta['handlers'], 'clearListeners' | 'removeListener'>) {
+    if (name)
+      this.handlers.removeListener(name, this.handlers[name])
+
+    this.handlers.clearListeners()
+  }
+
+  private createHandler<K extends Exclude<keyof ResolvedMeta['handlers'], 'clearListeners' | 'removeListener'>>(name: K) {
+    return (callback: VitestEvents[K]) => {
+      this.handlers[name](callback as any)
+    }
+  }
 }
 
 function createQueuedHandler<T>(resolver: (value: T[]) => Promise<void>) {
@@ -239,7 +234,10 @@ function createQueuedHandler<T>(resolver: (value: T[]) => Promise<void>) {
 
 export async function resolveVitestAPI(packages: VitestPackage[]) {
   const promises = packages.map(async (pkg) => {
-    const vitest = await createVitestProcess(pkg)
+    const config = getConfig(pkg.folder)
+    const vitest = config.shellType === 'terminal'
+      ? await createVitestTerminalProcess(pkg)
+      : await createVitestProcess(pkg)
     return new VitestFolderAPI(pkg, vitest)
   })
   const apis = await Promise.all(promises)
@@ -261,163 +259,3 @@ export interface ResolvedMeta {
     removeListener: (name: string, listener: any) => void
   }
 }
-
-function formapPkg(pkg: VitestPackage) {
-  return `Vitest v${pkg.version} (${relative(dirname(pkg.cwd), pkg.id)})`
-}
-
-async function createChildVitestProcess(pkg: VitestPackage) {
-  const pnpLoader = pkg.loader
-  const pnp = pkg.pnp
-  if (pnpLoader && !pnp)
-    throw new Error('pnp file is required if loader option is used')
-  const env = getConfig().env || {}
-  const execPath = await findNode(vscode.workspace.workspaceFile?.fsPath || pkg.cwd)
-  const execVersion = await getNodeJsVersion(execPath)
-  if (execVersion && !gte(execVersion, minimumNodeVersion)) {
-    const errorMsg = `Node.js version ${execVersion} is not supported. Minimum required version is ${minimumNodeVersion}`
-    log.error('[API]', errorMsg)
-    throw new Error(errorMsg)
-  }
-  const execArgv = pnpLoader && pnp // && !gte(execVersion, '18.19.0')
-    ? [
-        '--require',
-        pnp,
-        '--experimental-loader',
-        pathToFileURL(pnpLoader).toString(),
-      ]
-    : undefined
-  log.info('[API]', `Running ${formapPkg(pkg)} with Node.js@${execVersion}: ${execPath} ${execArgv ? execArgv.join(' ') : ''}`)
-  const logLevel = getConfig(pkg.folder).logLevel
-  const vitest = fork(
-    // to support pnp, we need to spawn `yarn node` instead of `node`
-    workerPath,
-    {
-      execPath,
-      execArgv,
-      env: {
-        ...process.env,
-        ...env,
-        VITEST_VSCODE_LOG: env.VITEST_VSCODE_LOG ?? process.env.VITEST_VSCODE_LOG ?? logLevel,
-        VITEST_VSCODE: 'true',
-        // same env var as `startVitest`
-        // https://github.com/vitest-dev/vitest/blob/5c7e9ca05491aeda225ce4616f06eefcd068c0b4/packages/vitest/src/node/cli/cli-api.ts
-        TEST: 'true',
-        VITEST: 'true',
-        NODE_ENV: env.NODE_ENV ?? process.env.NODE_ENV ?? 'test',
-      },
-      stdio: 'overlapped',
-      cwd: pnp ? dirname(pnp) : pkg.cwd,
-    },
-  )
-
-  vitest.stdout?.on('data', d => log.worker('info', d.toString()))
-  vitest.stderr?.on('data', (chunk) => {
-    const string = chunk.toString()
-    log.worker('error', string)
-    if (string.startsWith(' MISSING DEPENDENCY')) {
-      const error = string.split(/\r?\n/, 1)[0].slice(' MISSING DEPENDENCY'.length)
-      showVitestError(error)
-    }
-  })
-
-  return new Promise<ChildProcess>((resolve, reject) => {
-    function onMessage(message: WorkerEvent) {
-      if (message.type === 'debug')
-        log.worker('info', ...message.args)
-
-      if (message.type === 'ready') {
-        resolve(vitest)
-      }
-      if (message.type === 'error') {
-        const error = new Error(`Vitest failed to start: \n${message.error}`)
-        reject(error)
-      }
-      vitest.off('error', onError)
-      vitest.off('message', onMessage)
-      vitest.off('exit', onExit)
-    }
-
-    function onError(err: Error) {
-      log.error('[API]', err)
-      reject(err)
-      vitest.off('error', onError)
-      vitest.off('message', onMessage)
-      vitest.off('exit', onExit)
-    }
-
-    function onExit(code: number) {
-      reject(new Error(`Vitest process exited with code ${code}`))
-    }
-
-    vitest.on('error', onError)
-    vitest.on('message', onMessage)
-    vitest.on('exit', onExit)
-    vitest.once('spawn', () => {
-      const runnerOptions: WorkerRunnerOptions = {
-        type: 'init',
-        meta: {
-          vitestNodePath: pkg.vitestNodePath,
-          env: getConfig(pkg.folder).env || undefined,
-          configFile: pkg.configFile,
-          cwd: pkg.cwd,
-          arguments: pkg.arguments,
-          workspaceFile: pkg.workspaceFile,
-          id: pkg.id,
-          pnpApi: pnp,
-          pnpLoader: pnpLoader // && gte(execVersion, '18.19.0')
-            ? pathToFileURL(pnpLoader).toString()
-            : undefined,
-        },
-      }
-
-      vitest.send(runnerOptions)
-    })
-  })
-}
-
-export async function createVitestProcess(pkg: VitestPackage): Promise<ResolvedMeta> {
-  const vitest = await createChildVitestProcess(pkg)
-
-  log.info('[API]', `${formapPkg(pkg)} process ${vitest.pid} created`)
-
-  const { handlers, api } = createVitestRpc({
-    on: listener => vitest.on('message', listener),
-    send: message => vitest.send(message),
-  })
-
-  return {
-    rpc: api,
-    process: new VitestChildProcess(vitest),
-    handlers,
-    pkg,
-  }
-}
-
-class VitestChildProcess implements VitestProcess {
-  constructor(private child: ChildProcess) {}
-
-  get id() {
-    return this.child.pid ?? 0
-  }
-
-  get closed() {
-    return this.child.killed
-  }
-
-  on(event: string, listener: (...args: any[]) => void) {
-    this.child.on(event, listener)
-  }
-
-  once(event: string, listener: (...args: any[]) => void) {
-    this.child.once(event, listener)
-  }
-
-  off(event: string, listener: (...args: any[]) => void) {
-    this.child.off(event, listener)
-  }
-
-  close() {
-    this.child.kill()
-  }
-}