Due to wmic has been deprecated. Use @vscode/windows-process-tree for Windows process listing with WMIC fallback (#991)

* Use windows-process-tree on Windows for process listing

Add @vscode/windows-process-tree as a dependency and use it on Windows to enumerate processes (via promisified getAllProcesses). Fall back to the existing WMIC parser when windows-process-tree is unavailable. Update provider logic to return parsed process items from the native API on Windows and keep PS-based listing for macOS/Linux. Update unit tests to stub and exercise the new getAllProcesses flow and the WMIC fallback, and add webpack externals entry for the new native module.

* Update tests for getAllProcesses signature

Adjust Windows process provider unit tests to match the updated getAllProcesses API that accepts a flag parameter and uses an error-first callback. Stubs now use signatures like (_flag, callback) and call callback(null, processList); throwing stubs were updated to accept two arguments. These are test-only updates to align with the new function signature.

* Wrap wpc.getAllProcesses in a Promise

Replace use of util.promisify with an explicit Promise wrapper around wpc.getAllProcesses, removing the promisify import and adapting the call site to resolve with the process list. Update unit tests to match the changed callback shape (stubs now call callback(processList) and throw without an error-first parameter). This keeps Windows process enumeration working while aligning with the windows-process-tree callback behavior.

* Switch windows-process-tree from static import to dynamic require

Static imports can cause the entire module to fail if the native plugin's ABI doesn't match the running Node version.
Using dynamic `require()` within a `try-catch` statement allows for a fallback to WMIC if the module is unavailable or incompatible. To ensure compile-time type safety, only type imports are retained.
Add a comment to webpack externals explaining why the native addon must be excluded from bundling.

* Use block eslint-disable for naming-convention in tests

Replace single-line eslint-disable-next-line comments with explicit block disables/enables around the assertions in src/test/unittest/common/environment.unit.test.ts. This silences @typescript-eslint/naming-convention for the expected object literals (e.g. VAR1/VAR2) while keeping the rule enabled elsewhere.

* Format process-related calls for readability

Reformat long function calls in AttachProcessProvider for improved readability. Split arguments for wpc.getAllProcesses and logProcess into multiple lines (with trailing commas); no functional changes.

Author: ZA139

package-lock.json

@@ -687,6 +687,7 @@
         "@vscode/debugprotocol": "^1.65.0",
         "@vscode/extension-telemetry": "^0.8.4",
         "@vscode/python-extension": "^1.0.6",
+        "@vscode/windows-process-tree": "^0.7.0",
         "fs-extra": "^11.2.0",
         "iconv-lite": "^0.6.3",
         "jsonc-parser": "^3.0.0",

package.json

@@ -4,6 +4,7 @@
 'use strict';
 
 import { l10n } from 'vscode';
+import type { IProcessInfo } from '@vscode/windows-process-tree';
 import { getOSType, OSType } from '../../common/platform';
 import { PsProcessParser } from './psProcessParser';
 import { IAttachItem, IAttachProcessProvider, ProcessListCommand } from './types';
@@ -58,24 +59,52 @@ export class AttachProcessProvider implements IAttachProcessProvider {
     }
 
     public async _getInternalProcessEntries(): Promise<IAttachItem[]> {
-        let processCmd: ProcessListCommand;
         const osType = getOSType();
+
+        if (osType === OSType.Windows) {
+            try {
+                const wpc = require('@vscode/windows-process-tree');
+                const processList = await new Promise<IProcessInfo[]>((resolve) => {
+                    wpc.getAllProcesses(
+                        (processes: IProcessInfo[]) => resolve(processes),
+                        wpc.ProcessDataFlag.CommandLine,
+                    );
+                });
+                return processList.map((p) => ({
+                    label: p.name,
+                    description: String(p.pid),
+                    detail: p.commandLine || '',
+                    id: String(p.pid),
+                    processName: p.name,
+                    commandLine: p.commandLine || '',
+                }));
+            } catch {
+                const customEnvVars = await getEnvironmentVariables();
+                const output = await plainExec(
+                    WmicProcessParser.wmicCommand.command,
+                    WmicProcessParser.wmicCommand.args,
+                    { throwOnStdErr: true },
+                    customEnvVars,
+                );
+                logProcess(WmicProcessParser.wmicCommand.command, WmicProcessParser.wmicCommand.args, {
+                    throwOnStdErr: true,
+                });
+                return WmicProcessParser.parseProcesses(output.stdout);
+            }
+        }
+
+        let processCmd: ProcessListCommand;
         if (osType === OSType.OSX) {
             processCmd = PsProcessParser.psDarwinCommand;
         } else if (osType === OSType.Linux) {
             processCmd = PsProcessParser.psLinuxCommand;
-        } else if (osType === OSType.Windows) {
-            processCmd = WmicProcessParser.wmicCommand;
         } else {
             throw new Error(l10n.t("Operating system '{0}' not supported.", osType));
         }
 
         const customEnvVars = await getEnvironmentVariables();
         const output = await plainExec(processCmd.command, processCmd.args, { throwOnStdErr: true }, customEnvVars);
         logProcess(processCmd.command, processCmd.args, { throwOnStdErr: true });
-
-        return osType === OSType.Windows
-            ? WmicProcessParser.parseProcesses(output.stdout)
-            : PsProcessParser.parseProcesses(output.stdout);
+        return PsProcessParser.parseProcesses(output.stdout);
     }
 }