Co-authored-by: Daniel Imms <[email protected]>

Author: anthonykim1

.eslintrc

@@ -28,6 +28,7 @@
         "@typescript-eslint/no-dupe-class-members": "error",
         "no-empty-function": "off",
         "@typescript-eslint/no-empty-function": ["error"],
+        "no-inner-declarations": "warn",
         "@typescript-eslint/no-empty-interface": "off",
         "@typescript-eslint/no-explicit-any": "error",
         "@typescript-eslint/no-non-null-assertion": "off",

src/client/common/terminal/service.ts

@@ -39,6 +39,7 @@ export class TerminalService implements ITerminalService, Disposable {
         @inject(IServiceContainer) private serviceContainer: IServiceContainer,
         private readonly options?: TerminalCreationOptions,
     ) {
+        const a: TerminalService;
         const disposableRegistry = this.serviceContainer.get<Disposable[]>(IDisposableRegistry);
         disposableRegistry.push(this);
         this.terminalHelper = this.serviceContainer.get<ITerminalHelper>(ITerminalHelper);
@@ -74,6 +75,10 @@ export class TerminalService implements ITerminalService, Disposable {
             this.terminal!.show(preserveFocus);
         }
     }
+    //     When terminal is launched
+    //      Copy pythonrc into <userdata>/pythonrc.py
+    //      Update environment variable collection to include PYTHONSTARTUP=<userdata>/pythonrc.py
+
     public async ensureTerminal(preserveFocus: boolean = true): Promise<void> {
         if (this.terminal) {
             return;

src/client/extensionActivation.ts

@@ -32,7 +32,12 @@ import { TerminalProvider } from './providers/terminalProvider';
 import { setExtensionInstallTelemetryProperties } from './telemetry/extensionInstallTelemetry';
 import { registerTypes as tensorBoardRegisterTypes } from './tensorBoard/serviceRegistry';
 import { registerTypes as commonRegisterTerminalTypes } from './terminals/serviceRegistry';
-import { ICodeExecutionHelper, ICodeExecutionManager, ITerminalAutoActivation } from './terminals/types';
+import {
+    ICodeExecutionHelper,
+    ICodeExecutionManager,
+    IPythonStartupEnvVarService,
+    ITerminalAutoActivation,
+} from './terminals/types';
 import { registerTypes as unitTestsRegisterTypes } from './testing/serviceRegistry';
 
 // components
@@ -176,6 +181,7 @@ async function activateLegacy(ext: ExtensionState, startupStopWatch: StopWatch):
             serviceContainer.get<IApplicationDiagnostics>(IApplicationDiagnostics).register();
 
             serviceManager.get<ITerminalAutoActivation>(ITerminalAutoActivation).register();
+            serviceManager.get<IPythonStartupEnvVarService>(IPythonStartupEnvVarService).register();
 
             serviceManager.get<ICodeExecutionManager>(ICodeExecutionManager).registerCommands();
 

src/client/terminals/envCollectionActivation/service.ts

@@ -10,6 +10,7 @@ import {
     EnvironmentVariableScope,
     EnvironmentVariableMutatorOptions,
     ProgressLocation,
+    EnvironmentVariableCollection,
 } from 'vscode';
 import { pathExists, normCase } from '../../common/platform/fs-paths';
 import { IExtensionActivationService } from '../../activation/types';
@@ -37,7 +38,11 @@ import { TerminalShellType } from '../../common/terminal/types';
 import { OSType } from '../../common/utils/platform';
 
 import { PythonEnvType } from '../../pythonEnvironments/base/info';
-import { IShellIntegrationService, ITerminalDeactivateService, ITerminalEnvVarCollectionService } from '../types';
+import {
+    IShellIntegrationDetectionService,
+    ITerminalDeactivateService,
+    ITerminalEnvVarCollectionService,
+} from '../types';
 import { ProgressService } from '../../common/application/progressService';
 
 @injectable()
@@ -80,7 +85,8 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
         @inject(IConfigurationService) private readonly configurationService: IConfigurationService,
         @inject(ITerminalDeactivateService) private readonly terminalDeactivateService: ITerminalDeactivateService,
         @inject(IPathUtils) private readonly pathUtils: IPathUtils,
-        @inject(IShellIntegrationService) private readonly shellIntegrationService: IShellIntegrationService,
+        @inject(IShellIntegrationDetectionService)
+        private readonly shellIntegrationService: IShellIntegrationDetectionService,
         @inject(IEnvironmentVariablesProvider)
         private readonly environmentVariablesProvider: IEnvironmentVariablesProvider,
     ) {
@@ -91,7 +97,8 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
     public async activate(resource: Resource): Promise<void> {
         try {
             if (!inTerminalEnvVarExperiment(this.experimentService)) {
-                this.context.environmentVariableCollection.clear();
+                clearCollectionVariables(this.context.environmentVariableCollection);
+
                 await this.handleMicroVenv(resource);
                 if (!this.registeredOnce) {
                     this.interpreterService.onDidChangeInterpreter(
@@ -171,7 +178,7 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
         const settings = this.configurationService.getSettings(resource);
         const envVarCollection = this.getEnvironmentVariableCollection({ workspaceFolder });
         if (!settings.terminal.activateEnvironment) {
-            envVarCollection.clear();
+            clearCollectionVariables(envVarCollection);
             traceVerbose('Activating environments in terminal is disabled for', resource?.fsPath);
             return;
         }
@@ -193,7 +200,7 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
                 return;
             }
             await this.trackTerminalPrompt(shell, resource, env);
-            envVarCollection.clear();
+            clearCollectionVariables(envVarCollection);
             this.processEnvVars = undefined;
             return;
         }
@@ -210,7 +217,7 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
         const defaultPrependOptions = await this.getPrependOptions();
 
         // Clear any previously set env vars from collection
-        envVarCollection.clear();
+        clearCollectionVariables(envVarCollection);
         const deactivate = await this.terminalDeactivateService.getScriptLocation(shell, resource);
         Object.keys(env).forEach((key) => {
             if (shouldSkip(key)) {
@@ -367,7 +374,7 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
             const settings = this.configurationService.getSettings(resource);
             const workspaceFolder = this.getWorkspaceFolder(resource);
             if (!settings.terminal.activateEnvironment) {
-                this.getEnvironmentVariableCollection({ workspaceFolder }).clear();
+                clearCollectionVariables(this.getEnvironmentVariableCollection({ workspaceFolder }));
                 traceVerbose(
                     'Do not activate microvenv as activating environments in terminal is disabled for',
                     resource?.fsPath,
@@ -387,7 +394,7 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
                     );
                     return;
                 }
-                this.getEnvironmentVariableCollection({ workspaceFolder }).clear();
+                clearCollectionVariables(this.getEnvironmentVariableCollection({ workspaceFolder }));
             }
         } catch (ex) {
             traceWarn(`Microvenv failed as it is using proposed API which is constantly changing`, ex);
@@ -485,3 +492,9 @@ function normCaseKeys(env: EnvironmentVariables): EnvironmentVariables {
     });
     return result;
 }
+
+function clearCollectionVariables(collection: EnvironmentVariableCollection) {
+    for (const key of ['PS1', 'PATH']) {
+        collection.delete(key);
+    }
+}

src/client/terminals/envCollectionActivation/shellIntegrationService.ts

@@ -14,7 +14,7 @@ import { TerminalShellType } from '../../common/terminal/types';
 import { IDisposableRegistry, IPersistentStateFactory } from '../../common/types';
 import { sleep } from '../../common/utils/async';
 import { traceError, traceVerbose } from '../../logging';
-import { IShellIntegrationService } from '../types';
+import { IShellIntegrationDetectionService } from '../types';
 
 /**
  * This is a list of shells which support shell integration:
@@ -33,7 +33,7 @@ export enum isShellIntegrationWorking {
 }
 
 @injectable()
-export class ShellIntegrationService implements IShellIntegrationService {
+export class ShellIntegrationDetectionService implements IShellIntegrationDetectionService {
     private isWorkingForShell = new Set<TerminalShellType>();
 
     private readonly didChange = new EventEmitter<void>();

src/client/terminals/pythonstartupEnvVar/service.ts

@@ -0,0 +1,35 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import * as path from 'path';
+import { injectable, inject } from 'inversify';
+import { Uri, workspace } from 'vscode';
+import { IPythonStartupEnvVarService } from '../types';
+import { IExtensionContext } from '../../common/types';
+import { EXTENSION_ROOT_DIR } from '../../constants';
+
+@injectable()
+export class PythonStartupEnvVarService implements IPythonStartupEnvVarService {
+    constructor(@inject(IExtensionContext) private context: IExtensionContext) {}
+
+    public async register(): Promise<void> {
+        const storageUri = this.context.storageUri || this.context.globalStorageUri;
+        try {
+            await workspace.fs.createDirectory(storageUri);
+        } catch {
+            // already exists, most likely
+        }
+        const destPath = Uri.joinPath(storageUri, 'pythonrc.py');
+
+        // TODO: Only do this when we have a setting
+        // Rollout strategy:
+        // Stage 1. Opt-in setting in stable/insiders
+        // Stage 2. Out-out setting in insiders
+        // Stage 3. Out-out setting in stable (or experiment?)
+        const sourcePath = path.join(EXTENSION_ROOT_DIR, 'python_files', 'pythonrc.py');
+
+        await workspace.fs.copy(Uri.file(sourcePath), destPath, { overwrite: true });
+
+        this.context.environmentVariableCollection.replace('PYTHONSTARTUP', destPath.fsPath);
+    }
+}

src/client/terminals/serviceRegistry.ts

@@ -12,16 +12,18 @@ import {
     ICodeExecutionHelper,
     ICodeExecutionManager,
     ICodeExecutionService,
-    IShellIntegrationService,
+    IPythonStartupEnvVarService,
+    IShellIntegrationDetectionService,
     ITerminalAutoActivation,
     ITerminalDeactivateService,
     ITerminalEnvVarCollectionService,
 } from './types';
 import { TerminalEnvVarCollectionService } from './envCollectionActivation/service';
 import { IExtensionActivationService, IExtensionSingleActivationService } from '../activation/types';
 import { TerminalIndicatorPrompt } from './envCollectionActivation/indicatorPrompt';
-import { ShellIntegrationService } from './envCollectionActivation/shellIntegrationService';
+import { ShellIntegrationDetectionService } from './envCollectionActivation/shellIntegrationService';
 import { TerminalDeactivateService } from './envCollectionActivation/deactivateService';
+import { PythonStartupEnvVarService } from './pythonstartupEnvVar/service';
 
 export function registerTypes(serviceManager: IServiceManager): void {
     serviceManager.addSingleton<ICodeExecutionHelper>(ICodeExecutionHelper, CodeExecutionHelper);
@@ -50,6 +52,10 @@ export function registerTypes(serviceManager: IServiceManager): void {
         IExtensionSingleActivationService,
         TerminalIndicatorPrompt,
     );
-    serviceManager.addSingleton<IShellIntegrationService>(IShellIntegrationService, ShellIntegrationService);
+    serviceManager.addSingleton<IShellIntegrationDetectionService>(
+        IShellIntegrationDetectionService,
+        ShellIntegrationDetectionService,
+    );
+    serviceManager.addSingleton<IPythonStartupEnvVarService>(IPythonStartupEnvVarService, PythonStartupEnvVarService);
     serviceManager.addBinding(ITerminalEnvVarCollectionService, IExtensionActivationService);
 }

src/client/terminals/types.ts

@@ -42,8 +42,8 @@ export interface ITerminalEnvVarCollectionService {
     isTerminalPromptSetCorrectly(resource?: Resource): boolean;
 }
 
-export const IShellIntegrationService = Symbol('IShellIntegrationService');
-export interface IShellIntegrationService {
+export const IShellIntegrationDetectionService = Symbol('IShellIntegrationDetectionService');
+export interface IShellIntegrationDetectionService {
     onDidChangeStatus: Event<void>;
     isWorking(): Promise<boolean>;
 }
@@ -53,3 +53,8 @@ export interface ITerminalDeactivateService {
     initializeScriptParams(shell: string): Promise<void>;
     getScriptLocation(shell: string, resource: Resource): Promise<string | undefined>;
 }
+
+export const IPythonStartupEnvVarService = Symbol('IPythonStartupEnvVarService');
+export interface IPythonStartupEnvVarService {
+    register(): void;
+}

src/test/interpreters/activation/terminalEnvVarCollectionService.unit.test.ts

@@ -37,7 +37,7 @@ import { IInterpreterService } from '../../../client/interpreter/contracts';
 import { PathUtils } from '../../../client/common/platform/pathUtils';
 import { PythonEnvType } from '../../../client/pythonEnvironments/base/info';
 import { PythonEnvironment } from '../../../client/pythonEnvironments/info';
-import { IShellIntegrationService, ITerminalDeactivateService } from '../../../client/terminals/types';
+import { IShellIntegrationDetectionService, ITerminalDeactivateService } from '../../../client/terminals/types';
 import { IEnvironmentVariablesProvider } from '../../../client/common/variables/types';
 
 suite('Terminal Environment Variable Collection Service', () => {
@@ -58,7 +58,7 @@ suite('Terminal Environment Variable Collection Service', () => {
         title: Interpreters.activatingTerminals,
     };
     let configService: IConfigurationService;
-    let shellIntegrationService: IShellIntegrationService;
+    let shellIntegrationService: IShellIntegrationDetectionService;
     const displayPath = 'display/path';
     const customShell = 'powershell';
     const defaultShell = defaultShells[getOSType()];
@@ -76,7 +76,7 @@ suite('Terminal Environment Variable Collection Service', () => {
         context = mock<IExtensionContext>();
         shell = mock<IApplicationShell>();
         const envVarProvider = mock<IEnvironmentVariablesProvider>();
-        shellIntegrationService = mock<IShellIntegrationService>();
+        shellIntegrationService = mock<IShellIntegrationDetectionService>();
         when(shellIntegrationService.isWorking()).thenResolve(true);
         globalCollection = mock<GlobalEnvironmentVariableCollection>();
         collection = mock<EnvironmentVariableCollection>();

src/test/terminals/serviceRegistry.unit.test.ts

@@ -14,13 +14,13 @@ import { TerminalCodeExecutionProvider } from '../../client/terminals/codeExecut
 import { TerminalDeactivateService } from '../../client/terminals/envCollectionActivation/deactivateService';
 import { TerminalIndicatorPrompt } from '../../client/terminals/envCollectionActivation/indicatorPrompt';
 import { TerminalEnvVarCollectionService } from '../../client/terminals/envCollectionActivation/service';
-import { ShellIntegrationService } from '../../client/terminals/envCollectionActivation/shellIntegrationService';
+import { ShellIntegrationDetectionService } from '../../client/terminals/envCollectionActivation/shellIntegrationService';
 import { registerTypes } from '../../client/terminals/serviceRegistry';
 import {
     ICodeExecutionHelper,
     ICodeExecutionManager,
     ICodeExecutionService,
-    IShellIntegrationService,
+    IShellIntegrationDetectionService,
     ITerminalAutoActivation,
     ITerminalDeactivateService,
     ITerminalEnvVarCollectionService,
@@ -39,7 +39,7 @@ suite('Terminal - Service Registry', () => {
             [ITerminalEnvVarCollectionService, TerminalEnvVarCollectionService],
             [IExtensionSingleActivationService, TerminalIndicatorPrompt],
             [ITerminalDeactivateService, TerminalDeactivateService],
-            [IShellIntegrationService, ShellIntegrationService],
+            [IShellIntegrationDetectionService, ShellIntegrationDetectionService],
         ].forEach((args) => {
             if (args.length === 2) {
                 services