Fix issue where terminal environment variables are not removed when they are commented out or deleted from .env files. (#1131)

Fixes #936

The problem this PR fixed is when users comment out or remove a variable
from their .env file:
```
API_KEY=secret
# DEBUG=true   ← commented out
```

The DEBUG variable remained in terminal environments because:

1. `dotenv.parse()` ignores commented lines (seems the right behavior
per dotenv spec)
2. The returned object only contained active variables: `{ API_KEY:
'secret' }`
3. The old code only iterated over keys in `envVars` and it never saw
`DEBUG`
4. The `delete()` call was never reached for removed/commented variables

Solution is to call `clear()` before re-injecting variables, which makes
the fix stays at the terminal injection layer rather than modifying the
parsing layer, avoiding impacting on other consumers.

I also noticed some other issues with setting watcher, currently there's
no file watcher watching the settings change, so a reload will be
required when toggling the setting. We can consider adding a config
listener.

---------

Co-authored-by: Anthony Kim <62267334+anthonykim1@users.noreply.github.com>

Author: StellaHuang95

src/features/terminal/terminalEnvVarInjector.ts

@@ -22,6 +22,8 @@ import { EnvVarManager } from '../execution/envVariableManager';
  */
 export class TerminalEnvVarInjector implements Disposable {
     private disposables: Disposable[] = [];
+    // Track which .env variables we've set for each workspace to avoid clearing shell activation variables
+    private envVarKeys: Map<string, Set<string>> = new Map();
 
     constructor(
         private readonly envVarCollection: GlobalEnvironmentVariableCollection,
@@ -134,6 +136,8 @@ export class TerminalEnvVarInjector implements Disposable {
      */
     private async injectEnvironmentVariablesForWorkspace(workspaceFolder: WorkspaceFolder): Promise<void> {
         const workspaceUri = workspaceFolder.uri;
+        const workspaceKey = workspaceUri.fsPath;
+
         try {
             const envVars = await this.envVarManager.getEnvironmentVariables(workspaceUri);
 
@@ -149,6 +153,8 @@ export class TerminalEnvVarInjector implements Disposable {
                 traceVerbose(
                     `TerminalEnvVarInjector: Env file injection disabled for workspace: ${workspaceUri.fsPath}`,
                 );
+                // Clear only the .env variables we previously set, not shell activation variables
+                this.clearTrackedEnvVariables(envVarScope, workspaceKey);
                 return;
             }
 
@@ -165,17 +171,35 @@ export class TerminalEnvVarInjector implements Disposable {
                 traceVerbose(
                     `TerminalEnvVarInjector: No .env file found for workspace: ${workspaceUri.fsPath}, not injecting environment variables.`,
                 );
-                return; // No .env file to inject
+                // Clear only the .env variables we previously set, not shell activation variables
+                this.clearTrackedEnvVariables(envVarScope, workspaceKey);
+                return;
             }
 
-            for (const [key, value] of Object.entries(envVars)) {
-                if (value === undefined) {
-                    // Remove the environment variable if the value is undefined
+            // Get previously tracked keys for this workspace
+            const previousKeys = this.envVarKeys.get(workspaceKey) || new Set<string>();
+            const currentKeys = new Set<string>();
+
+            // Delete variables that were previously set but are no longer in the .env file.
+            // This ensures that when variables are commented out or removed from .env,
+            // they are properly removed from the terminal environment without affecting
+            // shell activation variables set by ShellStartupActivationVariablesManager.
+            for (const key of previousKeys) {
+                if (!(key in envVars)) {
                     envVarScope.delete(key);
-                } else {
+                }
+            }
+
+            // Set/update current variables
+            for (const [key, value] of Object.entries(envVars)) {
+                if (value !== undefined) {
                     envVarScope.replace(key, value);
+                    currentKeys.add(key);
                 }
             }
+
+            // Update tracking with current keys
+            this.envVarKeys.set(workspaceKey, currentKeys);
         } catch (error) {
             traceError(
                 `TerminalEnvVarInjector: Error injecting environment variables for workspace ${workspaceUri.fsPath}:`,
@@ -212,4 +236,20 @@ export class TerminalEnvVarInjector implements Disposable {
             traceError(`Failed to clear environment variables for workspace ${workspaceFolder.uri.fsPath}:`, error);
         }
     }
+
+    /**
+     * Clear only the .env variables we've tracked, not shell activation variables.
+     */
+    private clearTrackedEnvVariables(
+        envVarScope: ReturnType<GlobalEnvironmentVariableCollection['getScoped']>,
+        workspaceKey: string,
+    ): void {
+        const trackedKeys = this.envVarKeys.get(workspaceKey);
+        if (trackedKeys) {
+            for (const key of trackedKeys) {
+                envVarScope.delete(key);
+            }
+            this.envVarKeys.delete(workspaceKey);
+        }
+    }
 }