chore: refactor midway

Author: karthiknadig

files/scripts/startup.bat

@@ -0,0 +1,8 @@
+if "%TERM_PROGRAM%"=="vscode" (
+    if not defined VSCODE_PYTHON_AUTOACTIVATE_GUARD (
+        set "VSCODE_PYTHON_AUTOACTIVATE_GUARD=1"
+        if defined VSCODE_CMD_ACTIVATE (
+            call %VSCODE_CMD_ACTIVATE%
+        )
+    )
+)

files/scripts/startup.fish

@@ -0,0 +1,3 @@
+if set -q VSCODE_FISH_ACTIVATE
+    eval $VSCODE_FISH_ACTIVATE
+end

files/scripts/startup.nu

@@ -0,0 +1,3 @@
+if (($null -ne $env:VSCODE_PWSH_ACTIVATE)) {
+    Invoke-Expression $env:VSCODE_PWSH_ACTIVATE
+}

files/scripts/startup.ps1

@@ -0,0 +1,3 @@
+if [ -n "$VSCODE_BASH_ACTIVATE" ]; then
+    eval "$VSCODE_BASH_ACTIVATE"
+fi

files/scripts/startup.sh

@@ -56,13 +56,13 @@ import { registerTools } from './common/lm.apis';
 import { GetEnvironmentInfoTool, InstallPackageTool } from './features/copilotTools';
 import { TerminalActivationImpl } from './features/terminal/terminalActivationState';
 import { getEnvironmentForTerminal, normalizeShellPath } from './features/terminal/utils';
-import { PwshStartupProvider } from './features/terminal/startup/powershellStartup';
+import { PwshStartupProvider } from './features/terminal/startup/pwsh/pwshStartup';
 import { ShellStartupActivationManagerImpl } from './features/terminal/startup/activateUsingShellStartup';
 import {
     BashStartupProvider,
     GitBashStartupProvider,
     ZshStartupProvider,
-} from './features/terminal/startup/bashStartup';
+} from './features/terminal/startup/bash/bashStartup';
 import { FishStartupProvider } from './features/terminal/startup/fishStartup';
 import { isWindows } from './common/utils/platformUtils';
 import { CmdStartupProvider } from './features/terminal/startup/cmdStartup';

src/extension.ts

@@ -1,7 +1,7 @@
 import { ConfigurationChangeEvent, Disposable, GlobalEnvironmentVariableCollection } from 'vscode';
 import { getWorkspaceFolder, getWorkspaceFolders, onDidChangeConfiguration } from '../../../common/workspace.apis';
 import { getAutoActivationType, setAutoActivationType } from '../utils';
-import { ShellScriptEditState, ShellStartupProvider } from './startupProvider';
+import { ShellScriptEditState, ShellStartupScriptProvider } from './startupProvider';
 import { DidChangeEnvironmentEventArgs } from '../../../api';
 import { EnvironmentManagers } from '../../../internal.api';
 import { traceError, traceInfo } from '../../../common/logging';
@@ -18,7 +18,7 @@ export class ShellStartupActivationManagerImpl implements ShellStartupActivation
     private readonly disposables: Disposable[] = [];
     constructor(
         private readonly envCollection: GlobalEnvironmentVariableCollection,
-        private readonly shellStartupProviders: ShellStartupProvider[],
+        private readonly shellStartupProviders: ShellStartupScriptProvider[],
         private readonly em: EnvironmentManagers,
     ) {
         this.envCollection.description = ShellStartupActivationStrings.envCollectionDescription;
@@ -85,7 +85,7 @@ export class ShellStartupActivationManagerImpl implements ShellStartupActivation
         }
     }
 
-    private async getSetupRequired(): Promise<ShellStartupProvider[]> {
+    private async getSetupRequired(): Promise<ShellStartupScriptProvider[]> {
         const results = await Promise.all(
             this.shellStartupProviders.map(async (provider) => {
                 if (!(await provider.isSetup())) {
@@ -95,7 +95,7 @@ export class ShellStartupActivationManagerImpl implements ShellStartupActivation
             }),
         );
 
-        const providers = results.filter((provider): provider is ShellStartupProvider => provider !== undefined);
+        const providers = results.filter((provider): provider is ShellStartupScriptProvider => provider !== undefined);
         return providers;
     }
 

src/features/terminal/startup/activateUsingShellStartup.ts

@@ -0,0 +1,2 @@
+export const BASH_ENV_KEY = 'VSCODE_BASH_ACTIVATE';
+export const ZSH_ENV_KEY = 'VSCODE_ZSH_ACTIVATE';

src/features/terminal/startup/bash/bashConstants.ts

@@ -0,0 +1,84 @@
+import { EnvironmentVariableCollection } from 'vscode';
+import { PythonEnvironment } from '../../../../api';
+import { traceError } from '../../../../common/logging';
+import { getActivationCommandForShell } from '../../../common/activation';
+import { ShellConstants } from '../../../common/shellConstants';
+import { ShellEnvsProvider } from '../startupProvider';
+import { getCommandAsString } from '../utils';
+import { BASH_ENV_KEY, ZSH_ENV_KEY } from './bashConstants';
+
+export class BashEnvsProvider implements ShellEnvsProvider {
+    constructor(public readonly shell: 'bash' | 'gitbash') {}
+
+    async updateEnvVariables(collection: EnvironmentVariableCollection, env: PythonEnvironment): Promise<void> {
+        try {
+            const bashActivation = getActivationCommandForShell(env, this.shell);
+            if (bashActivation) {
+                const command = getCommandAsString(bashActivation, '&&');
+                collection.replace(BASH_ENV_KEY, command);
+            } else {
+                collection.delete(BASH_ENV_KEY);
+            }
+        } catch (err) {
+            traceError(`Failed to update env variables for ${this.shell}`, err);
+            collection.delete(BASH_ENV_KEY);
+        }
+    }
+
+    async removeEnvVariables(envCollection: EnvironmentVariableCollection): Promise<void> {
+        envCollection.delete(BASH_ENV_KEY);
+    }
+
+    async getEnvVariables(env?: PythonEnvironment): Promise<Map<string, string | undefined> | undefined> {
+        if (!env) {
+            return new Map([[BASH_ENV_KEY, undefined]]);
+        }
+
+        try {
+            const bashActivation = getActivationCommandForShell(env, ShellConstants.BASH);
+            if (bashActivation) {
+                const command = getCommandAsString(bashActivation, '&&');
+                return new Map([[BASH_ENV_KEY, command]]);
+            }
+            return undefined;
+        } catch (err) {
+            traceError(`Failed to get env variables for ${this.shell}`, err);
+            return undefined;
+        }
+    }
+}
+
+export class ZshEnvsProvider implements ShellEnvsProvider {
+    async updateEnvVariables(envVars: EnvironmentVariableCollection, env: PythonEnvironment): Promise<void> {
+        try {
+            const zshActivation = getActivationCommandForShell(env, ShellConstants.ZSH);
+            if (zshActivation) {
+                const command = getCommandAsString(zshActivation, '&&');
+                envVars.replace(ZSH_ENV_KEY, command);
+            } else {
+                envVars.delete(ZSH_ENV_KEY);
+            }
+        } catch (err) {
+            traceError('Failed to update env variables for zsh', err);
+            envVars.delete(ZSH_ENV_KEY);
+        }
+    }
+
+    async removeEnvVariables(envVars: EnvironmentVariableCollection): Promise<void> {
+        envVars.delete(ZSH_ENV_KEY);
+    }
+
+    async getEnvVariables(env?: PythonEnvironment): Promise<Map<string, string | undefined> | undefined> {
+        if (!env) {
+            return new Map([[ZSH_ENV_KEY, undefined]]);
+        }
+
+        try {
+            const zshActivation = getActivationCommandForShell(env, ShellConstants.ZSH);
+            return zshActivation ? new Map([[ZSH_ENV_KEY, getCommandAsString(zshActivation, '&&')]]) : undefined;
+        } catch (err) {
+            traceError('Failed to get env variables for zsh', err);
+            return undefined;
+        }
+    }
+}