Use windows-process-tree for Windows process list

Add support for @vscode/windows-process-tree to obtain process lists on Windows by promisifying getAllProcesses and mapping results to attach items, with a fallback to WMIC if the native module fails. Add unit tests covering successful retrieval, fallback behavior, sorting and Python-priority ordering. Update package.json and package-lock to include the new dependency and adjust webpack.config.js to exclude the native module from the bundle. Include a local .claude settings file for development permissions.

Author: ZA139

package-lock.json

@@ -682,6 +682,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

@@ -12,6 +12,9 @@ import { getEnvironmentVariables } from '../../common/python';
 import { plainExec } from '../../common/process/rawProcessApis';
 import { logProcess } from '../../common/process/logger';
 import { WmicProcessParser } from './wmicProcessParser';
+import { promisify } from 'util';
+import * as wpc from '@vscode/windows-process-tree';
+import { ProcessDataFlag } from '@vscode/windows-process-tree';
 
 export class AttachProcessProvider implements IAttachProcessProvider {
     constructor() {}
@@ -58,46 +61,71 @@ export class AttachProcessProvider implements IAttachProcessProvider {
         });
     }
 
+    /**
+     * Get processes via wmic (fallback)
+     */
+    private async _getProcessesViaWmic(): Promise<IAttachItem[]> {
+        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);
+    }
+
+    /**
+     * Get processes via Ps parser (Linux/macOS)
+     */
+    private async _getProcessesViaPsParser(cmd: ProcessListCommand): Promise<IAttachItem[]> {
+        const customEnvVars = await getEnvironmentVariables();
+        const output = await plainExec(cmd.command, cmd.args, { throwOnStdErr: true }, customEnvVars);
+        logProcess(cmd.command, cmd.args, { throwOnStdErr: true });
+        return PsProcessParser.parseProcesses(output.stdout);
+    }
+
     public async _getInternalProcessEntries(specCommand?: ProcessListCommand): Promise<IAttachItem[]> {
-        let processCmd: ProcessListCommand;
         if (specCommand === undefined) {
             const osType = getOSType();
             if (osType === OSType.OSX) {
-                processCmd = PsProcessParser.psDarwinCommand;
+                return this._getProcessesViaPsParser(PsProcessParser.psDarwinCommand);
             } else if (osType === OSType.Linux) {
-                processCmd = PsProcessParser.psLinuxCommand;
+                return this._getProcessesViaPsParser(PsProcessParser.psLinuxCommand);
             } else if (osType === OSType.Windows) {
-                processCmd = PowerShellProcessParser.powerShellCommand;
+                try {
+                    const getAllProcesses = promisify(wpc.getAllProcesses) as (flags?: ProcessDataFlag) => Promise<wpc.IProcessInfo[]>;
+                    const processList = await getAllProcesses(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 (error) {
+                    console.error('Failed to get processes via windows-process-tree:', error);
+                    // 降级到 wmic
+                    return this._getProcessesViaWmic();
+                }
             } else {
                 throw new Error(l10n.t("Operating system '{0}' not supported.", osType));
             }
-        } else {
-            processCmd = specCommand;
         }
+
+        const processCmd = specCommand;
         const customEnvVars = await getEnvironmentVariables();
-        if (processCmd === PowerShellProcessParser.powerShellCommand) {
-            try {
-                const checkPowerShell = await plainExec(
-                    'where',
-                    ['powershell'],
-                    { throwOnStdErr: false },
-                    customEnvVars,
-                );
-                if (checkPowerShell.stdout.length === 0) {
-                    processCmd = WmicProcessParser.wmicCommand;
-                }
-            } catch (error) {
-                // If 'where' fails, fall back to wmic (most likely powershell is not available).(Windows Xp or below？
-                console.log('PowerShell check failed, using WMIC fallback');
-                processCmd = WmicProcessParser.wmicCommand;
-            }
-        }
         const output = await plainExec(processCmd.command, processCmd.args, { throwOnStdErr: true }, customEnvVars);
         logProcess(processCmd.command, processCmd.args, { throwOnStdErr: true });
         if (processCmd === WmicProcessParser.wmicCommand) {
             return WmicProcessParser.parseProcesses(output.stdout);
-        } else if (processCmd === PowerShellProcessParser.powerShellCommand ||
-                   processCmd === PowerShellProcessParser.powerShellWithoutCimCommand) {
+        } else if (
+            processCmd === PowerShellProcessParser.powerShellCommand ||
+            processCmd === PowerShellProcessParser.powerShellWithoutCimCommand
+        ) {
             return PowerShellProcessParser.parseProcesses(output.stdout);
         }
         return PsProcessParser.parseProcesses(output.stdout);