.env file should not clear shellStartup env var

Author: anthonykim1

src/features/terminal/terminalEnvVarInjector.ts

@@ -3,17 +3,16 @@
 
 import * as fse from 'fs-extra';
 import * as path from 'path';
-import {
-    Disposable,
-    EnvironmentVariableScope,
-    GlobalEnvironmentVariableCollection,
-    window,
-    workspace,
-    WorkspaceFolder,
-} from 'vscode';
+import { Disposable, EnvironmentVariableScope, GlobalEnvironmentVariableCollection, WorkspaceFolder } from 'vscode';
 import { traceError, traceVerbose } from '../../common/logging';
 import { resolveVariables } from '../../common/utils/internalVariables';
-import { getConfiguration, getWorkspaceFolder } from '../../common/workspace.apis';
+import { showInformationMessage } from '../../common/window.apis';
+import {
+    getConfiguration,
+    getWorkspaceFolder,
+    getWorkspaceFolders,
+    onDidChangeConfiguration,
+} from '../../common/workspace.apis';
 import { EnvVarManager } from '../execution/envVariableManager';
 
 /**
@@ -65,7 +64,7 @@ export class TerminalEnvVarInjector implements Disposable {
 
                 // Only show notification when env vars change and we have an env file but injection is disabled
                 if (!useEnvFile && envFilePath) {
-                    window.showInformationMessage(
+                    showInformationMessage(
                         'An environment file is configured but terminal environment injection is disabled. Enable "python.terminal.useEnvFile" to use environment variables from .env files in terminals.',
                     );
                 }
@@ -83,7 +82,7 @@ export class TerminalEnvVarInjector implements Disposable {
 
         // Listen for changes to the python.envFile setting
         this.disposables.push(
-            workspace.onDidChangeConfiguration((e) => {
+            onDidChangeConfiguration((e) => {
                 if (e.affectsConfiguration('python.envFile')) {
                     traceVerbose(
                         'TerminalEnvVarInjector: python.envFile setting changed, updating environment variables',
@@ -113,7 +112,7 @@ export class TerminalEnvVarInjector implements Disposable {
             } else {
                 // No provided workspace - update all workspaces
 
-                const workspaceFolders = workspace.workspaceFolders;
+                const workspaceFolders = getWorkspaceFolders();
                 if (!workspaceFolders || workspaceFolders.length === 0) {
                     traceVerbose('TerminalEnvVarInjector: No workspace folders found, skipping env var injection');
                     return;
@@ -136,7 +135,8 @@ export class TerminalEnvVarInjector implements Disposable {
      */
     private async injectEnvironmentVariablesForWorkspace(workspaceFolder: WorkspaceFolder): Promise<void> {
         const workspaceUri = workspaceFolder.uri;
-        const workspaceKey = workspaceUri.fsPath;
+        // Use path.resolve() for safe cross-platform map key (Windows \ vs POSIX /)
+        const workspaceKey = path.resolve(workspaceUri.fsPath);
 
         try {
             const envVars = await this.envVarManager.getEnvironmentVariables(workspaceUri);
@@ -210,14 +210,25 @@ export class TerminalEnvVarInjector implements Disposable {
 
     /**
      * Dispose of the injector and clean up resources.
+     * Only clears the .env variables this injector has tracked, preserving
+     * shell activation variables (VSCODE_PYTHON_*_ACTIVATE) set by
+     * ShellStartupActivationVariablesManager on the same shared collection.
      */
     dispose(): void {
         traceVerbose('TerminalEnvVarInjector: Disposing');
         this.disposables.forEach((disposable) => disposable.dispose());
         this.disposables = [];
 
-        // Clear all environment variables from the collection
-        this.envVarCollection.clear();
+        // Only remove the .env keys we tracked — do NOT call envVarCollection.clear().
+        // The collection is shared with ShellStartupActivationVariablesManager which
+        // contributes VSCODE_PYTHON_*_ACTIVATE variables that must survive disposal.
+        const workspaceFolders = getWorkspaceFolders();
+        if (workspaceFolders) {
+            for (const folder of workspaceFolders) {
+                const scope = this.getEnvironmentVariableCollectionScoped({ workspaceFolder: folder });
+                this.clearTrackedEnvVariables(scope, path.resolve(folder.uri.fsPath));
+            }
+        }
     }
 
     private getEnvironmentVariableCollectionScoped(scope: EnvironmentVariableScope = {}) {
@@ -226,12 +237,14 @@ export class TerminalEnvVarInjector implements Disposable {
     }
 
     /**
-     * Clear all environment variables for a workspace.
+     * Clear .env variables for a workspace when the .env file is deleted.
+     * Only removes tracked keys, preserving shell activation variables
+     * (VSCODE_PYTHON_*_ACTIVATE) set by ShellStartupActivationVariablesManager.
      */
     private clearWorkspaceVariables(workspaceFolder: WorkspaceFolder): void {
         try {
             const scope = this.getEnvironmentVariableCollectionScoped({ workspaceFolder });
-            scope.clear();
+            this.clearTrackedEnvVariables(scope, path.resolve(workspaceFolder.uri.fsPath));
         } catch (error) {
             traceError(`Failed to clear environment variables for workspace ${workspaceFolder.uri.fsPath}:`, error);
         }

src/test/features/terminalEnvVarInjector.unit.test.ts

@@ -11,7 +11,6 @@ import {
     Uri,
     WorkspaceConfiguration,
     WorkspaceFolder,
-    workspace,
 } from 'vscode';
 import * as workspaceApis from '../../common/workspace.apis';
 import { EnvVarManager } from '../../features/execution/envVariableManager';
@@ -61,16 +60,10 @@ suite('TerminalEnvVarInjector', () => {
         envVarManager = typeMoq.Mock.ofType<EnvVarManager>();
 
         workspaceFoldersValue = [testWorkspaceFolder];
-        Object.defineProperty(workspace, 'workspaceFolders', {
-            get: () => workspaceFoldersValue,
-            configurable: true,
-        });
 
-        // Mock workspace.onDidChangeConfiguration to return a proper disposable
-        Object.defineProperty(workspace, 'onDidChangeConfiguration', {
-            value: () => new Disposable(() => {}),
-            configurable: true,
-        });
+        // Stub workspace.apis wrappers so TerminalEnvVarInjector uses mockable functions
+        sinon.stub(workspaceApis, 'getWorkspaceFolders').callsFake(() => workspaceFoldersValue);
+        sinon.stub(workspaceApis, 'onDidChangeConfiguration').returns(new Disposable(() => {}));
 
         mockScopedCollection = {
             clear: sinon.stub(),
@@ -108,10 +101,13 @@ suite('TerminalEnvVarInjector', () => {
             sinon.assert.match(injector, sinon.match.object);
         });
 
-        test('should dispose cleanly', () => {
+        test('should dispose without clearing the entire collection (preserves shell activation vars)', () => {
             injector = new TerminalEnvVarInjector(envVarCollection.object, envVarManager.object);
             injector.dispose();
-            envVarCollection.verify((c) => c.clear(), typeMoq.Times.atLeastOnce());
+            // dispose() must NOT call envVarCollection.clear() because the collection
+            // is shared with ShellStartupActivationVariablesManager which contributes
+            // VSCODE_PYTHON_*_ACTIVATE variables that must survive extension deactivation.
+            envVarCollection.verify((c) => c.clear(), typeMoq.Times.never());
         });
 
         test('should register environment variable change event handler', () => {