feat: support windows platform

- Add configuration for nodeExecutable path
  In the windows environment, The node path can not be detected system level by some node managers (e.g., fnm). So we added this parameter to specify the path of Node executable.

- use temporary configuration file when run wdio test on Windows platform
  Since the interpretation of the `reporters` parameter is not optimized for Windows, the original configuration file should be copied and tested in the Windows environment with the settings for Extension added.

Author: mato533

README.md

@@ -64,6 +64,7 @@ For example:
 
 This extension contributes the following settings:
 
+- `webdriverio.nodeExecutable`: The path to the Node.js executable. If not assigned, WebdriverIO try to resolve the node path from environment valuables of `PATH`.
 - `webdriverio.configFilePattern`: Glob pattern for WebdriverIO configuration file
 - `webdriverio.logLevel`: Set the logLevel
 - `webdriverio.showOutput`: Show WebdriverIO output in the test result when set `true` this option

package.json

@@ -52,6 +52,10 @@
         "configuration": {
             "title": "WebdriverIO",
             "properties": {
+                "webdriverio.nodeExecutable": {
+                    "markdownDescription": "The path to the Node.js executable. If not assigned, WebdriverIO just passes down `'node'` to `child_process.spawn`.",
+                    "type": "string"
+                },
                 "webdriverio.configFilePattern": {
                     "type": "array",
                     "items": {

packages/vscode-wdio-api/src/debug.ts

@@ -5,6 +5,7 @@ import * as vscode from 'vscode'
 
 import { TestRunner } from './run.js'
 import { WdioExtensionWorker } from './worker.js'
+import type { ExtensionConfigManagerInterface } from '@vscode-wdio/types/config'
 import type { TestItemMetadata } from '@vscode-wdio/types/test'
 
 let debuggerId = 0
@@ -22,11 +23,15 @@ export class DebugRunner extends TestRunner {
     private _runController: AbortController | null = null
 
     constructor(
+        configManager: ExtensionConfigManagerInterface,
         workspaceFolder: vscode.WorkspaceFolder | undefined,
         token: vscode.CancellationToken,
         workerCwd: string,
-        worker = new WdioExtensionDebugWorker(`#DEBUGGER${debuggerId++}`, workerCwd, workspaceFolder, token)
+        _worker?: WdioExtensionDebugWorker
     ) {
+        const worker = _worker
+            ? _worker
+            : new WdioExtensionDebugWorker(configManager, `#DEBUGGER${debuggerId++}`, workerCwd, workspaceFolder, token)
         super(worker)
 
         worker.setDebugTerminationCallback(() => {
@@ -75,12 +80,13 @@ export class WdioExtensionDebugWorker extends WdioExtensionWorker {
     private _debugTerminationCallback: (() => void) | null = null
 
     constructor(
+        configManager: ExtensionConfigManagerInterface,
         cid: string = '#0',
         cwd: string,
         private _workspaceFolder: vscode.WorkspaceFolder | undefined,
         private _token: vscode.CancellationToken
     ) {
-        super(cid, cwd)
+        super(configManager, cid, cwd)
     }
 
     /**

packages/vscode-wdio-api/src/manager.ts

@@ -1,9 +1,11 @@
 import { dirname, normalize } from 'node:path'
 
 import { log } from '@vscode-wdio/logger'
+import * as vscode from 'vscode'
 
 import { WdioExtensionWorker } from './worker.js'
 import type { ServerManagerInterface, WdioExtensionWorkerInterface } from '@vscode-wdio/types/api'
+import type { ExtensionConfigManagerInterface } from '@vscode-wdio/types/config'
 
 export class ServerManager implements ServerManagerInterface {
     private _serverPool = new Map<string, WdioExtensionWorkerInterface>()
@@ -13,6 +15,28 @@ export class ServerManager implements ServerManagerInterface {
     private _operationLock = false
     private _operationQueue: (() => Promise<void>)[] = []
 
+    constructor(private readonly configManager: ExtensionConfigManagerInterface) {
+        configManager.on('update:nodeExecutable', async (nodeExecutable: string) => {
+            log.debug(`Restart worker using webdriverio.nodeExecutable: ${nodeExecutable}`)
+            const cwds = Array.from(this._serverPool.keys())
+            await Promise.all(
+                cwds.map(async (cwd) => {
+                    const worker = this._serverPool.get(cwd)
+                    if (worker) {
+                        await this.stopWorker(cwd, worker)
+                    }
+                })
+            )
+            try {
+                await this.start(this.configManager.getWdioConfigPaths())
+            } catch (error) {
+                const errorMessage = `Failed to restart WebdriverIO worker process: ${error instanceof Error ? error.message : String(error)}`
+                log.error(errorMessage)
+                vscode.window.showErrorMessage(errorMessage)
+            }
+        })
+    }
+
     /**
      * Start worker process directory by directory which is located the wdio config file.
      * @param configPaths path to the configuration file for wdio (e.g. /path/to/wdio.config.js)
@@ -28,7 +52,7 @@ export class ServerManager implements ServerManagerInterface {
             })
 
             const workerCwds = Array.from(duplicatedWorkerCwds)
-            const ids = Array.from({ length: workerCwds.length }, (_, i) => i)
+            const ids = Array.from({ length: workerCwds.length }, (_, i) => this.latestId + i)
             this.latestId = ids[ids.length - 1]
 
             await Promise.all(
@@ -146,35 +170,35 @@ export class ServerManager implements ServerManagerInterface {
         }
     }
 
-    private async startWorker(id: number, configPaths: string): Promise<WdioExtensionWorkerInterface> {
+    private async startWorker(id: number, workerCwd: string): Promise<WdioExtensionWorkerInterface> {
         // Return existing server if already created
-        const existingServer = this._serverPool.get(configPaths)
+        const existingServer = this._serverPool.get(workerCwd)
         if (existingServer) {
             return existingServer
         }
 
         // Return pending operation if one is in progress
-        const pendingOperation = this._pendingOperations.get(`start:${configPaths}`)
+        const pendingOperation = this._pendingOperations.get(`start:${workerCwd}`)
         if (pendingOperation) {
             return pendingOperation as Promise<WdioExtensionWorkerInterface>
         }
 
         // Start a new process and track it
-        const serverPromise = this.createWorker(id, configPaths)
-        this._pendingOperations.set(`start:${configPaths}`, serverPromise)
+        const serverPromise = this.createWorker(id, workerCwd)
+        this._pendingOperations.set(`start:${workerCwd}`, serverPromise)
 
         try {
             const server = await serverPromise
             return server
         } finally {
             // Remove from pending list when completed
-            this._pendingOperations.delete(`start:${configPaths}`)
+            this._pendingOperations.delete(`start:${workerCwd}`)
         }
     }
 
     private async createWorker(id: number, configPaths: string): Promise<WdioExtensionWorker> {
         const strId = `#${String(id)}`
-        const server = new WdioExtensionWorker(strId, configPaths)
+        const server = new WdioExtensionWorker(this.configManager, strId, configPaths)
         await server.start()
         await server.waitForStart()
         log.debug(`[server manager] server was registered: ${configPaths}`)

packages/vscode-wdio-api/src/utils.ts

@@ -1,8 +1,12 @@
+import * as fs from 'node:fs/promises'
+
 import { LOG_LEVEL, TEST_ID_SEPARATOR } from '@vscode-wdio/constants'
 import { log } from '@vscode-wdio/logger'
+import which from 'which'
 import { WebSocketServer } from 'ws'
 
 import type { Server } from 'node:http'
+import type { ExtensionConfigManagerInterface } from '@vscode-wdio/types/config'
 import type { TestItemMetadataWithRepository } from '@vscode-wdio/types/test'
 import type { NumericLogLevel } from '@vscode-wdio/types/utils'
 import type * as vscode from 'vscode'
@@ -90,3 +94,33 @@ export function getCucumberSpec(testItem: vscode.TestItem, metadata: TestItemMet
     }
     return baseSpec
 }
+
+export async function resolveNodePath(configManager: ExtensionConfigManagerInterface) {
+    log.debug('Resolving the Node executable path')
+    const configuredPath = configManager.globalConfig.nodeExecutable
+    if (configuredPath && (await checkExistence(configuredPath))) {
+        log.debug(`Resolved executable path: ${configuredPath}`)
+        return configuredPath
+    }
+
+    const foundPath = await which('node', { nothrow: true })
+    if (foundPath && (await checkExistence(foundPath))) {
+        log.debug(`Resolved executable path: ${foundPath}`)
+        return foundPath
+    }
+    const msg = `Unable to find 'node' executable.\nMake sure to have Node.js installed and available in your PATH.\nCurrent PATH: '${process.env.PATH}'.`
+    log.error(msg)
+    throw new Error(msg)
+}
+
+async function checkExistence(targetPath: string) {
+    log.debug(`Access check: ${targetPath}`)
+    try {
+        await fs.access(targetPath, fs.constants.X_OK)
+        return true
+    } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error)
+        log.debug(`Access check was failed: ${msg}`)
+        return false
+    }
+}

packages/vscode-wdio-api/src/worker.ts

@@ -8,14 +8,16 @@ import { log } from '@vscode-wdio/logger'
 import { createBirpc } from 'birpc'
 import getPort from 'get-port'
 
-import { createWss, loggingFn } from './utils.js'
+import { createWss, loggingFn, resolveNodePath } from './utils.js'
 
 import type { ExtensionApi, WdioExtensionWorkerInterface, WorkerApi } from '@vscode-wdio/types/api'
+import type { ExtensionConfigManagerInterface } from '@vscode-wdio/types/config'
 import type * as vscode from 'vscode'
 import type { WebSocketServer } from 'ws'
 
 const WORKER_PATH = resolve(__dirname, 'worker.cjs')
 export class WdioExtensionWorker extends EventEmitter implements WdioExtensionWorkerInterface {
+    protected configManager: ExtensionConfigManagerInterface
     public cid: string
     protected cwd: string
     protected disposables: vscode.Disposable[] = []
@@ -26,10 +28,11 @@ export class WdioExtensionWorker extends EventEmitter implements WdioExtensionWo
     private _server: Server | null = null
     private _wss: WebSocketServer | null = null
 
-    constructor(cid: string = '#0', cwd: string) {
+    constructor(configManager: ExtensionConfigManagerInterface, cid: string = '#0', cwd: string) {
         super()
         this.cid = cid
         this.cwd = cwd
+        this.configManager = configManager
 
         const psListener = () => {
             if (this._workerProcess && !this._workerProcess.killed) {
@@ -73,6 +76,7 @@ export class WdioExtensionWorker extends EventEmitter implements WdioExtensionWo
             return
         }
         try {
+            const nodeExecutable = await resolveNodePath(this.configManager)
             // Find available port for WebSocket communication
             // Store server instances for proper cleanup
             const wsUrl = await this.getServer()
@@ -86,7 +90,7 @@ export class WdioExtensionWorker extends EventEmitter implements WdioExtensionWo
             }
 
             // Start worker process
-            this._workerProcess = spawn('node', [WORKER_PATH], {
+            this._workerProcess = spawn(nodeExecutable, [WORKER_PATH], {
                 cwd: this.cwd,
                 env,
                 stdio: 'pipe',

packages/vscode-wdio-api/tests/debug.test.ts

@@ -7,6 +7,8 @@ import { DebugRunner, DebugSessionTerminatedError, WdioExtensionDebugWorker } fr
 import * as runModule from '../src/run.js'
 import * as workerModule from '../src/worker.js'
 
+import type { ExtensionConfigManagerInterface } from '@vscode-wdio/types/config'
+
 // Mock VSCode
 vi.mock('vscode', async () => {
     const mockModule = await import('../../../tests/__mocks__/vscode.cjs')
@@ -24,6 +26,8 @@ vi.mock('vscode', async () => {
 // Mock logger
 vi.mock('@vscode-wdio/logger', () => import('../../../tests/__mocks__/logger.js'))
 
+const mockConfigManager = {} as unknown as ExtensionConfigManagerInterface
+
 describe('DebugRunner', () => {
     let workspaceFolder: vscode.WorkspaceFolder
     let debugRunner: DebugRunner
@@ -73,7 +77,7 @@ describe('DebugRunner', () => {
         })
 
         // Create debug runner instance
-        debugRunner = new DebugRunner(workspaceFolder, mockToken, '/path/to/worker/cwd', mockWorker)
+        debugRunner = new DebugRunner(mockConfigManager, workspaceFolder, mockToken, '/path/to/worker/cwd', mockWorker)
     })
 
     afterEach(() => {
@@ -215,7 +219,13 @@ describe('WdioExtensionDebugWorker', () => {
         vi.spyOn(workerModule.WdioExtensionWorker.prototype, 'stop').mockResolvedValue(undefined)
 
         // Create worker instance
-        debugWorker = new WdioExtensionDebugWorker('#DEBUGGER1', '/path/to', workspaceFolder, mockToken)
+        debugWorker = new WdioExtensionDebugWorker(
+            mockConfigManager,
+            '#DEBUGGER1',
+            '/path/to',
+            workspaceFolder,
+            mockToken
+        )
 
         // Mock getServer method
         vi.spyOn(debugWorker as any, 'getServer').mockResolvedValue('ws://localhost:1234')

packages/vscode-wdio-api/tests/manager.test.ts

@@ -4,10 +4,13 @@ import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
 
 import { ServerManager } from '../src/manager.js'
 import { WdioExtensionWorker } from '../src/worker.js'
+import type { ExtensionConfigManagerInterface } from '@vscode-wdio/types/config'
+
+vi.mock('vscode', () => import('../../../tests/__mocks__/vscode.cjs'))
 
 // Mock the worker.js module
 vi.mock('../src/worker.js', () => {
-    const WdioExtensionWorker = vi.fn(function (cid, configPath) {
+    const WdioExtensionWorker = vi.fn(function (_configManager, cid, configPath) {
         // @ts-ignore
         this.cid = cid
         // @ts-ignore
@@ -22,13 +25,26 @@ vi.mock('../src/worker.js', () => {
 // Mock the logger module
 vi.mock('@vscode-wdio/logger', () => import('../../../tests/__mocks__/logger.js'))
 
+vi.mock('../src/utils.js', async (importActual) => {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-imports
+    const actual = await importActual<typeof import('../src/utils.js')>()
+    return {
+        ...actual,
+        resolveNodePath: vi.fn(),
+    }
+})
+
+const mockConfigManager = {
+    on: vi.fn(),
+} as unknown as ExtensionConfigManagerInterface
+
 describe('ServerManager', () => {
     let serverManager: ServerManager
 
     // Create a fresh instance of ServerManager before each test
     beforeEach(() => {
         vi.resetAllMocks()
-        serverManager = new ServerManager()
+        serverManager = new ServerManager(mockConfigManager)
     })
 
     afterEach(() => {
@@ -45,8 +61,8 @@ describe('ServerManager', () => {
 
             // Assert
             expect(WdioExtensionWorker).toHaveBeenCalledTimes(2)
-            expect(WdioExtensionWorker).toHaveBeenCalledWith('#0', normalize('/path/to'))
-            expect(WdioExtensionWorker).toHaveBeenCalledWith('#1', normalize('/another/path'))
+            expect(WdioExtensionWorker).toHaveBeenCalledWith(mockConfigManager, '#0', normalize('/path/to'))
+            expect(WdioExtensionWorker).toHaveBeenCalledWith(mockConfigManager, '#1', normalize('/another/path'))
 
             // Check that start was called on each worker
             expect(vi.mocked(WdioExtensionWorker).mock.instances.length).toBe(2)
@@ -90,7 +106,7 @@ describe('ServerManager', () => {
 
             // Assert
             expect(WdioExtensionWorker).toHaveBeenCalledTimes(1)
-            expect(WdioExtensionWorker).toHaveBeenCalledWith('#1', wdioDirName)
+            expect(WdioExtensionWorker).toHaveBeenCalledWith(mockConfigManager, '#1', wdioDirName)
             expect(result).toBeDefined()
             expect(result.cid).toBe('#1')
         })
@@ -104,8 +120,8 @@ describe('ServerManager', () => {
 
             // Assert
             expect(WdioExtensionWorker).toHaveBeenCalledTimes(2)
-            expect(WdioExtensionWorker).toHaveBeenCalledWith('#1', '/path/to')
-            expect(WdioExtensionWorker).toHaveBeenCalledWith('#2', '/another/path')
+            expect(WdioExtensionWorker).toHaveBeenCalledWith(mockConfigManager, '#1', '/path/to')
+            expect(WdioExtensionWorker).toHaveBeenCalledWith(mockConfigManager, '#2', '/another/path')
         })
     })
 
@@ -149,7 +165,7 @@ describe('ServerManager', () => {
 
             // Should create one new worker
             expect(WdioExtensionWorker).toHaveBeenCalledTimes(1)
-            expect(WdioExtensionWorker).toHaveBeenCalledWith('#2', normalize('/new/path'))
+            expect(WdioExtensionWorker).toHaveBeenCalledWith(mockConfigManager, '#2', normalize('/new/path'))
         })
     })
 
@@ -235,7 +251,7 @@ describe('ServerManager', () => {
 
             // Assert
             expect(WdioExtensionWorker).toHaveBeenCalledTimes(1)
-            expect(WdioExtensionWorker).toHaveBeenCalledWith('#42', configPath)
+            expect(WdioExtensionWorker).toHaveBeenCalledWith(mockConfigManager, '#42', configPath)
             expect(result).toBeDefined()
             expect(result.start).toHaveBeenCalledTimes(1)
             expect(result.waitForStart).toHaveBeenCalledTimes(1)
@@ -256,7 +272,7 @@ describe('ServerManager', () => {
                 createWorkerCalls++
                 // Mock delay to ensure operations overlap
                 await new Promise((resolve) => setTimeout(resolve, 50))
-                return new WdioExtensionWorker(`#${id}`, path)
+                return new WdioExtensionWorker(mockConfigManager, `#${id}`, path)
             }) as any)
 
             // Execute two concurrent calls with same path