first draft

Author: eleanorjboyd

src/extension/common/application/commands/reportIssueCommand.ts

@@ -8,7 +8,6 @@ import * as path from 'path';
 import { executeCommand } from '../../vscodeapi';
 import { getActiveEnvironmentPath, resolveEnvironment } from '../../python';
 import { EXTENSION_ROOT_DIR } from '../../constants';
-import { getRawVersion } from '../../settings';
 import { sendTelemetryEvent } from '../../../telemetry';
 import { EventName } from '../../../telemetry/constants';
 
@@ -22,9 +21,9 @@ export async function openReportIssue(): Promise<void> {
     const userTemplate = await fs.readFile(userDataTemplatePath, 'utf8');
     const interpreterPath = await getActiveEnvironmentPath();
     const interpreter = await resolveEnvironment(interpreterPath);
-    const virtualEnvKind = interpreter?.environment?.type || 'Unknown';
+    const virtualEnvKind = interpreter?.envId.managerId ?? 'N/A';
 
-    const pythonVersion = getRawVersion(interpreter?.version);
+    const pythonVersion = interpreter?.version ?? 'unknown';
     await executeCommand('workbench.action.openIssueReporter', {
         extensionId: 'ms-python.debugpy',
         issueBody: template,

src/extension/common/python.ts

@@ -11,19 +11,16 @@ import {
     ResolvedEnvironment,
     Resource,
 } from '@vscode/python-extension';
-import { commands, EventEmitter, extensions, Uri, Event, Disposable, Extension } from 'vscode';
-import { createDeferred } from './utils/async';
+import { commands, EventEmitter, extensions, Uri, Event, Disposable } from 'vscode';
 import { traceError, traceLog } from './log/logging';
+import { PythonEnvironment, PythonEnvironmentApi, PythonEnvsExtension } from '../envExtApi';
 
-/**
- * Interface for the Python extension API.
- */
-interface IExtensionApi {
-    ready: Promise<void>;
-    settings: {
-        getExecutionDetails(resource?: Resource): { execCommand: string[] | undefined };
-    };
-}
+// interface IExtensionApi {
+//     ready: Promise<void>;
+//     settings: {
+//         getExecutionDetails(resource?: Resource): { execCommand: string[] | undefined };
+//     };
+// }
 
 /**
  * Details about a Python interpreter.
@@ -70,20 +67,18 @@ async function activateEnvsExtension(): Promise<Extension<any> | undefined> {
     return extension;
 }
 
-/**
- * Gets the Python extension's API interface.
- * @returns The Python extension API or undefined if not available
- */
-async function getPythonExtensionAPI(): Promise<IExtensionApi | undefined> {
-    const extension = await activateExtension();
-    return extension?.exports as IExtensionApi;
+async function getPythonEnviromentExtensionAPI(): Promise<PythonEnvironmentApi> {
+    // Load the Python extension API
+    await activateEnvsExtension();
+    return await PythonEnvsExtension.api();
 }
 
-/**
- * Gets the Python extension's environment API.
- * @returns The Python extension environment API
- */
-async function getPythonExtensionEnviromentAPI(): Promise<PythonExtension> {
+// async function getLegacyPythonExtensionAPI(): Promise<IExtensionApi | undefined> {
+//     const extension = await activateExtension();
+//     return extension?.exports as IExtensionApi;
+// }
+
+async function getLegacyPythonExtensionEnviromentAPI(): Promise<PythonExtension> {
     // Load the Python extension API
     await activateExtension();
     return await PythonExtension.api();
@@ -95,7 +90,7 @@ async function getPythonExtensionEnviromentAPI(): Promise<PythonExtension> {
  */
 export async function initializePython(disposables: Disposable[]): Promise<void> {
     try {
-        const api = await getPythonExtensionEnviromentAPI();
+        const api = await getLegacyPythonExtensionEnviromentAPI();
 
         if (api) {
             disposables.push(
@@ -140,86 +135,115 @@ export async function runPythonExtensionCommand(command: string, ...rest: any[])
  * @returns Array of command components or undefined if not available
  */
 export async function getSettingsPythonPath(resource?: Uri): Promise<string[] | undefined> {
-    const api = await getPythonExtensionAPI();
-    return api?.settings.getExecutionDetails(resource).execCommand;
+    // const api = await getLegacyPythonExtensionAPI();
+    // return api?.settings.getExecutionDetails(resource).execCommand;
+
+    const apiNew = await getPythonEnviromentExtensionAPI();
+    const abc: PythonEnvironment[] = await apiNew.getEnvironments(resource || 'all');
+    console.log('Python envs:', abc);
+    return undefined;
 }
 
-/**
- * Returns the environment variables used by the extension for a resource, which includes the custom
- * variables configured by user in `.env` files.
- * @param resource Optional workspace resource to get environment variables for
- * @returns Environment variables object
- */
-export async function getEnvironmentVariables(resource?: Resource): Promise<EnvironmentVariables> {
-    const api = await getPythonExtensionEnviromentAPI();
-    return Promise.resolve(api.environments.getEnvironmentVariables(resource));
+export async function getEnvironmentVariables(resource?: Resource) {
+    const api = await getLegacyPythonExtensionEnviromentAPI();
+    return api.environments.getEnvironmentVariables(resource);
 }
 
-/**
- * Returns details for the given environment, or `undefined` if the env is invalid.
- * @param env Environment to resolve (can be Environment object, path, or string)
- * @returns Resolved environment details
- */
 export async function resolveEnvironment(
     env: Environment | EnvironmentPath | string,
+): Promise<PythonEnvironment | undefined> {
+    // const api = await getLegacyPythonExtensionEnviromentAPI();
+    // return api.environments.resolveEnvironment(env);
+
+    const apiNew = await getPythonEnviromentExtensionAPI();
+
+    // Handle different input types for the new API
+    if (typeof env === 'string') {
+        // Convert string path to Uri for the new API
+        return apiNew.resolveEnvironment(Uri.file(env));
+    } else if (typeof env === 'object' && 'path' in env) {
+        // EnvironmentPath has a uri property
+        return apiNew.resolveEnvironment(Uri.file(env.path));
+    } else {
+        return undefined;
+    }
+}
+
+export async function legacyResolveEnvironment(
+    env: Environment | EnvironmentPath | string,
 ): Promise<ResolvedEnvironment | undefined> {
-    const api = await getPythonExtensionEnviromentAPI();
+    const api = await getLegacyPythonExtensionEnviromentAPI();
     return api.environments.resolveEnvironment(env);
 }
 
-/**
- * Returns the environment configured by user in settings. Note that this can be an invalid environment, use
- * resolve the environment to get full details.
- * @param resource Optional workspace resource to get active environment for
- * @returns Path to the active environment
- */
-export async function getActiveEnvironmentPath(resource?: Resource): Promise<EnvironmentPath> {
-    const api = await getPythonExtensionEnviromentAPI();
+export async function getLegacyActiveEnvironmentPath(resource?: Resource) {
+    const api = await getLegacyPythonExtensionEnviromentAPI();
     return api.environments.getActiveEnvironmentPath(resource);
 }
 
+export async function getActiveEnvironmentPath(resource?: Resource): Promise<PythonEnvironment | undefined> {
+    const api = await getPythonEnviromentExtensionAPI();
+
+    // Convert Resource to Uri if it exists
+    let resourceUri: Uri | undefined;
+    if (resource instanceof Uri) {
+        resourceUri = resource;
+    } else if (resource && 'uri' in resource) {
+        // WorkspaceFolder type
+        resourceUri = resource.uri;
+    }
+
+    return api.getEnvironment(resourceUri);
+}
+
 /**
- * Gets detailed information about the active Python interpreter.
- * @param resource Optional workspace resource to get interpreter details for
- * @returns Interpreter details including path and resource information
+ * Gets Python interpreter details using the legacy Python extension API.
+ *
+ * This function retrieves the active Python environment for a given resource using the
+ * legacy @vscode/python-extension API. It resolves the environment to get the executable
+ * path and handles path quoting for paths containing spaces.
+ *
+ * @param resource Optional URI to specify the workspace/folder context for interpreter selection
+ * @returns Promise resolving to interpreter details containing the executable path and resource
  */
-export async function getInterpreterDetails(resource?: Uri): Promise<IInterpreterDetails> {
-    const api = await getPythonExtensionEnviromentAPI();
+export async function getLegacyInterpreterDetails(resource?: Uri): Promise<IInterpreterDetails> {
+    const api = await getLegacyPythonExtensionEnviromentAPI();
+
     const environment = await api.environments.resolveEnvironment(api.environments.getActiveEnvironmentPath(resource));
     if (environment?.executable.uri) {
         return { path: [environment?.executable.uri.fsPath], resource };
     }
     return { path: undefined, resource };
 }
 
-/**
- * Checks if any Python interpreters are available in the system.
- * @returns True if interpreters are found, false otherwise
- */
-export async function hasInterpreters(): Promise<boolean> {
-    const api = await getPythonExtensionEnviromentAPI();
-    const onAddedToCollection = createDeferred();
-    api.environments.onDidChangeEnvironments(async () => {
-        if (api.environments.known) {
-            onAddedToCollection.resolve();
-        }
-    });
-    const initialEnvs = api.environments.known;
-    if (initialEnvs.length > 0) {
-        return true;
+export function quoteStringIfNecessary(arg: string): string {
+    // Always return if already quoted to avoid double-quoting
+    if (arg.startsWith('"') && arg.endsWith('"')) {
+        return arg;
     }
-    // Initiates a refresh of Python environments within the specified scope.
-    await Promise.race([onAddedToCollection.promise, api?.environments.refreshEnvironments()]);
 
-    return api.environments.known.length > 0;
+    // Quote if contains common shell special characters that are problematic across multiple shells
+    // Includes: space, &, |, <, >, ;, ', ", `, (, ), [, ], {, }, $
+    const needsQuoting = /[\s&|<>;'"`()\[\]{}$]/.test(arg);
+
+    return needsQuoting ? `"${arg}"` : arg;
 }
 
-/**
- *  Gets environments known to the extension at the time of fetching the property. Note this may not
- * contain all environments in the system as a refresh might be going on.
- * @returns Array of known Python environments
- */
-export async function getInterpreters(): Promise<readonly Environment[]> {
-    const api = await getPythonExtensionEnviromentAPI();
-    return api.environments.known || [];
+export async function getInterpreterDetails(resource?: Uri): Promise<IInterpreterDetails> {
+    const api = await getPythonEnviromentExtensionAPI();
+
+    // A promise that resolves to the current Python environment, or undefined if none is set.
+    const env: PythonEnvironment | undefined = await api.getEnvironment(resource);
+    // resolve the environment to get full details
+    const resolvedEnv = env ? await api.resolveEnvironment(env?.environmentPath) : undefined;
+    const executablePath = resolvedEnv?.execInfo.activatedRun?.executable
+        ? resolvedEnv.execInfo.activatedRun.executable
+        : resolvedEnv?.execInfo.run.executable;
+
+    // Quote the executable path if necessary
+    const a: IInterpreterDetails = {
+        path: executablePath ? [quoteStringIfNecessary(executablePath)] : undefined,
+        resource,
+    };
+    return a;
 }

src/extension/common/settings.ts

@@ -2,10 +2,10 @@
 // Licensed under the MIT License.
 
 import { ConfigurationChangeEvent, ConfigurationTarget, Uri, WorkspaceConfiguration, WorkspaceFolder } from 'vscode';
-import { getInterpreterDetails } from './python';
 import { getConfiguration, getWorkspaceFolder, getWorkspaceFolders } from './vscodeapi';
 import { isUnitTestExecution } from './constants';
 import { VersionInfo } from '@vscode/python-extension';
+import { getInterpreterDetails } from './python';
 
 export interface ISettings {
     workspace: string;

src/extension/debugger/adapter/factory.ts

@@ -23,8 +23,8 @@ import { getInterpreterDetails, resolveEnvironment, runPythonExtensionCommand }
 import { Commands, EXTENSION_ROOT_DIR } from '../../common/constants';
 import { Common, DebugConfigStrings, Interpreters } from '../../common/utils/localize';
 import { IPersistentStateFactory } from '../../common/types';
-import { ResolvedEnvironment } from '@vscode/python-extension';
 import { fileToCommandArgumentForPythonExt } from '../../common/stringUtils';
+import { PythonEnvironment } from '../../envExtApi';
 
 // persistent state names, exported to make use of in testing
 export enum debugStateKeys {
@@ -177,15 +177,32 @@ export class DebugAdapterDescriptorFactory implements IDebugAdapterDescriptorFac
         }
     }
 
-    private async getExecutableCommand(interpreter: ResolvedEnvironment | undefined): Promise<string[]> {
+    /**
+     * Extracts the executable command from a resolved Python environment.
+     *
+     * This function takes a resolved Python environment and returns the path to the Python
+     * executable as a string array suitable for spawning processes. It also performs version
+     * validation, showing a deprecation warning if the Python version is below 3.9.
+     *
+     * @param interpreter The resolved Python environment containing executable path and version info
+     * @returns Promise resolving to an array containing the Python executable path, or empty array if no interpreter
+     */
+    private async getExecutableCommand(interpreter: PythonEnvironment | undefined): Promise<string[]> {
         if (interpreter) {
-            if (
-                (interpreter.version?.major ?? 0) < 3 ||
-                ((interpreter.version?.major ?? 0) <= 3 && (interpreter.version?.minor ?? 0) < 9)
-            ) {
+            const executablePath = interpreter.execInfo.activatedRun?.executable ?? interpreter.execInfo.run.executable;
+            const version = interpreter.version;
+
+            // Parse version string (e.g., "3.8.10" -> major: 3, minor: 8)
+            const parseMajorMinor = (v: string) => {
+                const m = v.match(/^(\d+)(?:\.(\d+))?/);
+                return { major: m ? Number(m[1]) : 0, minor: m && m[2] ? Number(m[2]) : 0 };
+            };
+            const { major, minor } = parseMajorMinor(version || '');
+
+            if (major < 3 || (major <= 3 && minor < 9)) {
                 this.showDeprecatedPythonMessage();
             }
-            return interpreter.path.length > 0 ? [interpreter.path] : [];
+            return executablePath ? [executablePath] : [];
         }
         return [];
     }