Merge branch 'main' into energetic-hummingbird

Author: eleanorjboyd

package-lock.json

@@ -2,7 +2,7 @@
     "name": "vscode-python-envs",
     "displayName": "Python Environments",
     "description": "Provides a unified python environment experience",
-    "version": "1.20.0",
+    "version": "1.21.0",
     "publisher": "ms-python",
     "preview": true,
     "engines": {

package.json

@@ -168,6 +168,9 @@ export namespace CondaStrings {
     export const condaMissingPythonNoFix = l10n.t(
         'No Python found in the selected conda environment. Please select another environment or install Python manually.',
     );
+    export const condaCondaPrefixActive = l10n.t(
+        'CONDA_PREFIX is set for this VS Code session. Selection saved for new terminals only.',
+    );
 }
 
 export namespace PyenvStrings {

src/common/localize.ts

@@ -494,8 +494,9 @@ export async function activate(context: ExtensionContext): Promise<PythonEnviron
             }
             const envVar = shellEnv.value;
             if (envVar) {
-                if (envVar['VIRTUAL_ENV']) {
-                    const envPath = normalizeShellPath(envVar['VIRTUAL_ENV'], e.terminal.state.shell);
+                const envVarPath = envVar['VIRTUAL_ENV'] || envVar['CONDA_PREFIX'];
+                if (envVarPath) {
+                    const envPath = normalizeShellPath(envVarPath, e.terminal.state.shell);
                     const env = await api.resolveEnvironment(Uri.file(envPath));
                     if (env) {
                         monitoredTerminals.set(e.terminal, env);

src/extension.ts

@@ -59,12 +59,7 @@ export interface TerminalInit {
 }
 
 export interface TerminalManager
-    extends TerminalEnvironment,
-        TerminalInit,
-        TerminalActivation,
-        TerminalCreation,
-        TerminalGetters,
-        Disposable {}
+    extends TerminalEnvironment, TerminalInit, TerminalActivation, TerminalCreation, TerminalGetters, Disposable {}
 
 export class TerminalManagerImpl implements TerminalManager {
     private disposables: Disposable[] = [];
@@ -321,7 +316,7 @@ export class TerminalManagerImpl implements TerminalManager {
 
     private dedicatedTerminals = new Map<string, Terminal>();
     async getDedicatedTerminal(
-        terminalKey: Uri,
+        terminalKey: Uri | string,
         project: Uri | PythonProject,
         environment: PythonEnvironment,
         createNew: boolean = false,
@@ -336,17 +331,26 @@ export class TerminalManagerImpl implements TerminalManager {
         }
 
         const puri = project instanceof Uri ? project : project.uri;
-        const config = getConfiguration('python', terminalKey);
+        const config = getConfiguration('python', terminalKey instanceof Uri ? terminalKey : puri);
         const projectStat = await fsapi.stat(puri.fsPath);
         const projectDir = projectStat.isDirectory() ? puri.fsPath : path.dirname(puri.fsPath);
 
-        const uriStat = await fsapi.stat(terminalKey.fsPath);
-        const uriDir = uriStat.isDirectory() ? terminalKey.fsPath : path.dirname(terminalKey.fsPath);
-        const cwd = config.get<boolean>('terminal.executeInFileDir', false) ? uriDir : projectDir;
+        let cwd: string;
+        let name: string;
+
+        if (terminalKey instanceof Uri) {
+            const uriStat = await fsapi.stat(terminalKey.fsPath);
+            const uriDir = uriStat.isDirectory() ? terminalKey.fsPath : path.dirname(terminalKey.fsPath);
+            cwd = config.get<boolean>('terminal.executeInFileDir', false) ? uriDir : projectDir;
+            // Follow Python extension's naming: 'Python: {filename}' for dedicated terminals
+            const fileName = path.basename(terminalKey.fsPath).replace('.py', '');
+            name = `Python: ${fileName}`;
+        } else {
+            // When terminalKey is a string, use project directory and the string as name
+            cwd = projectDir;
+            name = `Python: ${terminalKey}`;
+        }
 
-        // Follow Python extension's naming: 'Python: {filename}' for dedicated terminals
-        const fileName = path.basename(terminalKey.fsPath).replace('.py', '');
-        const name = `Python: ${fileName}`;
         const newTerminal = await this.create(environment, { cwd, name });
         this.dedicatedTerminals.set(key, newTerminal);
 

src/features/terminal/terminalManager.ts

@@ -23,7 +23,7 @@ import { CondaStrings } from '../../common/localize';
 import { traceError } from '../../common/logging';
 import { createDeferred, Deferred } from '../../common/utils/deferred';
 import { normalizePath } from '../../common/utils/pathUtils';
-import { showErrorMessage, withProgress } from '../../common/window.apis';
+import { showErrorMessage, showInformationMessage, withProgress } from '../../common/window.apis';
 import { NativePythonFinder } from '../common/nativePythonFinder';
 import { CondaSourcingStatus } from './condaSourcingUtils';
 import {
@@ -289,6 +289,16 @@ export class CondaEnvManager implements EnvironmentManager, Disposable {
             const folder = this.api.getPythonProject(scope);
             const fsPath = folder?.uri?.fsPath ?? scope.fsPath;
             if (fsPath) {
+                // Notify user if CONDA_PREFIX is set and they're trying to select a different environment
+                if (process.env.CONDA_PREFIX && checkedEnv) {
+                    const condaPrefixPath = process.env.CONDA_PREFIX;
+                    const selectedPath = checkedEnv.environmentPath.fsPath;
+                    // Only show notification if they selected a different environment
+                    if (condaPrefixPath !== selectedPath) {
+                        showInformationMessage(CondaStrings.condaCondaPrefixActive);
+                    }
+                }
+
                 const normalizedFsPath = normalizePath(fsPath);
                 if (checkedEnv) {
                     this.fsPathToEnv.set(normalizedFsPath, checkedEnv);

src/managers/conda/condaEnvManager.ts

@@ -82,6 +82,10 @@ export function getCondaPathSetting(): string | undefined {
 }
 
 export async function getCondaForWorkspace(fsPath: string): Promise<string | undefined> {
+    if (process.env.CONDA_PREFIX) {
+        return process.env.CONDA_PREFIX;
+    }
+
     const state = await getWorkspacePersistentState();
     const data: { [key: string]: string } | undefined = await state.get(CONDA_WORKSPACE_KEY);
     if (data) {

src/managers/conda/condaUtils.ts

@@ -6,16 +6,22 @@ import * as fsapi from 'fs-extra';
 import * as os from 'os';
 import * as path from 'path';
 import * as sinon from 'sinon';
-import { Disposable, Event, EventEmitter, Progress, Terminal, TerminalOptions, Uri, WorkspaceConfiguration } from 'vscode';
+import {
+    Disposable,
+    Event,
+    EventEmitter,
+    Progress,
+    Terminal,
+    TerminalOptions,
+    Uri,
+    WorkspaceConfiguration,
+} from 'vscode';
 import { PythonEnvironment } from '../../../api';
 import * as windowApis from '../../../common/window.apis';
 import * as workspaceApis from '../../../common/workspace.apis';
 import * as activationUtils from '../../../features/common/activation';
 import * as shellDetector from '../../../features/common/shellDetector';
-import {
-    ShellEnvsProvider,
-    ShellStartupScriptProvider,
-} from '../../../features/terminal/shells/startupProvider';
+import { ShellEnvsProvider, ShellStartupScriptProvider } from '../../../features/terminal/shells/startupProvider';
 import {
     DidChangeTerminalActivationStateEvent,
     TerminalActivationInternal,
@@ -309,13 +315,109 @@ suite('TerminalManager - terminal naming', () => {
         try {
             await terminalManager.getProjectTerminal(projectUri, env);
 
+            assert.strictEqual(optionsList[0]?.name, 'Python', 'Project terminal should use the Python title');
+        } finally {
+            await fsapi.remove(tempRoot);
+        }
+    });
+
+    // Regression test for https://github.com/microsoft/vscode-python-environments/issues/1230
+    test('getDedicatedTerminal with string key uses string as terminal name', async () => {
+        mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_OFF);
+        terminalManager = createTerminalManager();
+        const env = createMockEnvironment();
+
+        const optionsList: TerminalOptions[] = [];
+        createTerminalStub.callsFake((options) => {
+            optionsList.push(options);
+            return mockTerminal as Terminal;
+        });
+
+        const tempRoot = await fsapi.mkdtemp(path.join(os.tmpdir(), 'py-envs-'));
+        const projectPath = path.join(tempRoot, 'project');
+        await fsapi.ensureDir(projectPath);
+        const projectUri = Uri.file(projectPath);
+
+        const config = { get: sinon.stub().returns(false) } as unknown as WorkspaceConfiguration;
+        sinon.stub(workspaceApis, 'getConfiguration').returns(config);
+
+        try {
+            await terminalManager.getDedicatedTerminal('my-terminal-key', projectUri, env);
+
             assert.strictEqual(
                 optionsList[0]?.name,
-                'Python',
-                'Project terminal should use the Python title',
+                'Python: my-terminal-key',
+                'Dedicated terminal with string key should use the string in the title',
+            );
+            assert.strictEqual(
+                Uri.file(optionsList[0]?.cwd as string).fsPath,
+                Uri.file(projectPath).fsPath,
+                'Dedicated terminal with string key should use project directory as cwd',
             );
         } finally {
             await fsapi.remove(tempRoot);
         }
     });
+
+    // Regression test for https://github.com/microsoft/vscode-python-environments/issues/1230
+    test('getDedicatedTerminal with string key reuses terminal for same key', async () => {
+        mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_OFF);
+        terminalManager = createTerminalManager();
+        const env = createMockEnvironment();
+
+        let createCount = 0;
+        createTerminalStub.callsFake((options) => {
+            createCount++;
+            return { ...mockTerminal, name: options.name } as Terminal;
+        });
+
+        const tempRoot = await fsapi.mkdtemp(path.join(os.tmpdir(), 'py-envs-'));
+        const projectPath = path.join(tempRoot, 'project');
+        await fsapi.ensureDir(projectPath);
+        const projectUri = Uri.file(projectPath);
+
+        const config = { get: sinon.stub().returns(false) } as unknown as WorkspaceConfiguration;
+        sinon.stub(workspaceApis, 'getConfiguration').returns(config);
+
+        try {
+            const terminal1 = await terminalManager.getDedicatedTerminal('my-key', projectUri, env);
+            const terminal2 = await terminalManager.getDedicatedTerminal('my-key', projectUri, env);
+
+            assert.strictEqual(terminal1, terminal2, 'Same string key should return the same terminal');
+            assert.strictEqual(createCount, 1, 'Terminal should be created only once');
+        } finally {
+            await fsapi.remove(tempRoot);
+        }
+    });
+
+    // Regression test for https://github.com/microsoft/vscode-python-environments/issues/1230
+    test('getDedicatedTerminal with string key uses different terminals for different keys', async () => {
+        mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_OFF);
+        terminalManager = createTerminalManager();
+        const env = createMockEnvironment();
+
+        let createCount = 0;
+        createTerminalStub.callsFake((options) => {
+            createCount++;
+            return { ...mockTerminal, name: options.name, id: createCount } as unknown as Terminal;
+        });
+
+        const tempRoot = await fsapi.mkdtemp(path.join(os.tmpdir(), 'py-envs-'));
+        const projectPath = path.join(tempRoot, 'project');
+        await fsapi.ensureDir(projectPath);
+        const projectUri = Uri.file(projectPath);
+
+        const config = { get: sinon.stub().returns(false) } as unknown as WorkspaceConfiguration;
+        sinon.stub(workspaceApis, 'getConfiguration').returns(config);
+
+        try {
+            const terminal1 = await terminalManager.getDedicatedTerminal('key-1', projectUri, env);
+            const terminal2 = await terminalManager.getDedicatedTerminal('key-2', projectUri, env);
+
+            assert.notStrictEqual(terminal1, terminal2, 'Different string keys should return different terminals');
+            assert.strictEqual(createCount, 2, 'Two terminals should be created');
+        } finally {
+            await fsapi.remove(tempRoot);
+        }
+    });
 });