feat: add "Don't Show Again" button to env file notification

Adds a "Don't Show Again" button to the information notification that
appears when an environment file is configured but terminal environment
injection is disabled. The preference is persisted in global state so
it survives between sessions.

- Add `Common.dontShowAgain` localized string
- Add `ENV_FILE_NOTIFICATION_DONT_SHOW_KEY` persistent state key
- Use `showInformationMessage` wrapper instead of direct `window` API
- Extract notification logic to `showEnvFileNotification()` method
- Add 5 unit tests covering the new behavior

Fixes #419

Co-authored-by: eleanorjboyd <26030610+eleanorjboyd@users.noreply.github.com>
Agent-Logs-Url: https://github.com/microsoft/vscode-python-environments/sessions/d9efb122-775e-4477-9005-10a94641311d

Author: Copilot

src/common/localize.ts

@@ -15,6 +15,7 @@ export namespace Common {
     export const ok = l10n.t('Ok');
     export const quickCreate = l10n.t('Quick Create');
     export const installPython = l10n.t('Install Python');
+    export const dontShowAgain = l10n.t("Don't Show Again");
 }
 
 export namespace WorkbenchStrings {

src/features/terminal/terminalEnvVarInjector.ts

@@ -7,15 +7,19 @@ import {
     Disposable,
     EnvironmentVariableScope,
     GlobalEnvironmentVariableCollection,
-    window,
     workspace,
     WorkspaceFolder,
 } from 'vscode';
-import { traceError, traceVerbose } from '../../common/logging';
+import { Common } from '../../common/localize';
+import { traceError, traceLog, traceVerbose } from '../../common/logging';
+import { getGlobalPersistentState } from '../../common/persistentState';
 import { resolveVariables } from '../../common/utils/internalVariables';
+import { showInformationMessage } from '../../common/window.apis';
 import { getConfiguration, getWorkspaceFolder } from '../../common/workspace.apis';
 import { EnvVarManager } from '../execution/envVariableManager';
 
+export const ENV_FILE_NOTIFICATION_DONT_SHOW_KEY = 'python-envs:terminal:ENV_FILE_NOTIFICATION_DONT_SHOW';
+
 /**
  * Manages injection of workspace-specific environment variables into VS Code terminals
  * using the GlobalEnvironmentVariableCollection API.
@@ -65,9 +69,9 @@ 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(
-                        'An environment file is configured but terminal environment injection is disabled. Enable "python.terminal.useEnvFile" to use environment variables from .env files in terminals.',
-                    );
+                    this.showEnvFileNotification().catch((error) => {
+                        traceError('Failed to show env file notification:', error);
+                    });
                 }
 
                 if (args.changeType === 2) {
@@ -208,6 +212,26 @@ export class TerminalEnvVarInjector implements Disposable {
         }
     }
 
+    /**
+     * Show a notification about env file injection being disabled, with a "Don't Show Again" option.
+     */
+    private async showEnvFileNotification(): Promise<void> {
+        const state = await getGlobalPersistentState();
+        const dontShow = await state.get<boolean>(ENV_FILE_NOTIFICATION_DONT_SHOW_KEY);
+        if (dontShow) {
+            return;
+        }
+
+        const result = await 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.',
+            Common.dontShowAgain,
+        );
+        if (result === Common.dontShowAgain) {
+            await state.set(ENV_FILE_NOTIFICATION_DONT_SHOW_KEY, true);
+            traceLog('User selected "Don\'t Show Again" for env file notification');
+        }
+    }
+
     /**
      * Dispose of the injector and clean up resources.
      */

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

@@ -13,9 +13,15 @@ import {
     WorkspaceFolder,
     workspace,
 } from 'vscode';
+import { Common } from '../../common/localize';
+import * as persistentState from '../../common/persistentState';
+import * as windowApis from '../../common/window.apis';
 import * as workspaceApis from '../../common/workspace.apis';
 import { EnvVarManager } from '../../features/execution/envVariableManager';
-import { TerminalEnvVarInjector } from '../../features/terminal/terminalEnvVarInjector';
+import {
+    ENV_FILE_NOTIFICATION_DONT_SHOW_KEY,
+    TerminalEnvVarInjector,
+} from '../../features/terminal/terminalEnvVarInjector';
 
 interface MockScopedCollection {
     clear: sinon.SinonStub;
@@ -307,4 +313,125 @@ suite('TerminalEnvVarInjector', () => {
             }
         });
     });
+
+    suite('env file notification with Don\'t Show Again', () => {
+        let envChangeCallback: ((args: { uri?: Uri; changeType: number }) => void) | undefined;
+        let mockState: { get: sinon.SinonStub; set: sinon.SinonStub; clear: sinon.SinonStub };
+        let showInfoMessageStub: sinon.SinonStub;
+
+        setup(() => {
+            mockState = {
+                get: sinon.stub(),
+                set: sinon.stub().resolves(),
+                clear: sinon.stub().resolves(),
+            };
+            sinon.stub(persistentState, 'getGlobalPersistentState').resolves(mockState);
+            showInfoMessageStub = sinon.stub(windowApis, 'showInformationMessage');
+
+            // Capture the onDidChangeEnvironmentVariables listener
+            envVarManager.reset();
+            envVarManager
+                .setup((m) => m.onDidChangeEnvironmentVariables)
+                .returns(() => {
+                    return (listener: (args: { uri?: Uri; changeType: number }) => void): Disposable => {
+                        envChangeCallback = listener;
+                        return new Disposable(() => {});
+                    };
+                });
+            envVarManager
+                .setup((m) => m.getEnvironmentVariables(typeMoq.It.isAny()))
+                .returns(() => Promise.resolve({}));
+
+            sinon.stub(workspaceApis, 'getWorkspaceFolder').returns(testWorkspaceFolder);
+        });
+
+        test('should show notification with Don\'t Show Again button when env file configured but injection disabled', async () => {
+            getConfigurationStub.returns(
+                createMockConfig({ useEnvFile: false, envFilePath: '${workspaceFolder}/.env' }) as WorkspaceConfiguration,
+            );
+            mockState.get.resolves(false);
+            showInfoMessageStub.resolves(undefined);
+
+            injector = new TerminalEnvVarInjector(envVarCollection.object, envVarManager.object);
+            await new Promise((resolve) => setTimeout(resolve, 50));
+
+            assert.ok(envChangeCallback, 'Event handler should be registered');
+            envChangeCallback!({ uri: Uri.file(testWorkspacePath), changeType: 1 });
+            await new Promise((resolve) => setTimeout(resolve, 50));
+
+            assert.ok(showInfoMessageStub.calledOnce, 'Should show notification');
+            assert.ok(
+                showInfoMessageStub.calledWith(sinon.match.string, Common.dontShowAgain),
+                'Should include Don\'t Show Again button',
+            );
+        });
+
+        test('should not show notification when Don\'t Show Again was previously selected', async () => {
+            getConfigurationStub.returns(
+                createMockConfig({ useEnvFile: false, envFilePath: '${workspaceFolder}/.env' }) as WorkspaceConfiguration,
+            );
+            mockState.get.resolves(true);
+
+            injector = new TerminalEnvVarInjector(envVarCollection.object, envVarManager.object);
+            await new Promise((resolve) => setTimeout(resolve, 50));
+
+            assert.ok(envChangeCallback, 'Event handler should be registered');
+            envChangeCallback!({ uri: Uri.file(testWorkspacePath), changeType: 1 });
+            await new Promise((resolve) => setTimeout(resolve, 50));
+
+            assert.ok(showInfoMessageStub.notCalled, 'Should not show notification when dismissed');
+        });
+
+        test('should persist preference when Don\'t Show Again is clicked', async () => {
+            getConfigurationStub.returns(
+                createMockConfig({ useEnvFile: false, envFilePath: '${workspaceFolder}/.env' }) as WorkspaceConfiguration,
+            );
+            mockState.get.resolves(false);
+            showInfoMessageStub.resolves(Common.dontShowAgain);
+
+            injector = new TerminalEnvVarInjector(envVarCollection.object, envVarManager.object);
+            await new Promise((resolve) => setTimeout(resolve, 50));
+
+            assert.ok(envChangeCallback, 'Event handler should be registered');
+            envChangeCallback!({ uri: Uri.file(testWorkspacePath), changeType: 1 });
+            await new Promise((resolve) => setTimeout(resolve, 50));
+
+            assert.ok(
+                mockState.set.calledWith(ENV_FILE_NOTIFICATION_DONT_SHOW_KEY, true),
+                'Should persist Don\'t Show Again preference',
+            );
+        });
+
+        test('should not show notification when useEnvFile is true', async () => {
+            getConfigurationStub.returns(
+                createMockConfig({ useEnvFile: true, envFilePath: '${workspaceFolder}/.env' }) as WorkspaceConfiguration,
+            );
+            mockState.get.resolves(false);
+
+            injector = new TerminalEnvVarInjector(envVarCollection.object, envVarManager.object);
+            await new Promise((resolve) => setTimeout(resolve, 50));
+
+            assert.ok(envChangeCallback, 'Event handler should be registered');
+            envChangeCallback!({ uri: Uri.file(testWorkspacePath), changeType: 1 });
+            await new Promise((resolve) => setTimeout(resolve, 50));
+
+            assert.ok(showInfoMessageStub.notCalled, 'Should not show notification when useEnvFile is true');
+        });
+
+        test('should not show notification when no envFile is configured', async () => {
+            getConfigurationStub.returns(
+                createMockConfig({ useEnvFile: false }) as WorkspaceConfiguration,
+            );
+            mockState.get.resolves(false);
+
+            injector = new TerminalEnvVarInjector(envVarCollection.object, envVarManager.object);
+            await new Promise((resolve) => setTimeout(resolve, 50));
+
+            assert.ok(envChangeCallback, 'Event handler should be registered');
+            envChangeCallback!({ uri: Uri.file(testWorkspacePath), changeType: 1 });
+            await new Promise((resolve) => setTimeout(resolve, 50));
+
+            assert.ok(showInfoMessageStub.notCalled, 'Should not show notification when no envFile configured');
+        });
+    });
 });