Auto activation of environment in new terminals

Author: DonJayamanne

src/client/common/application/terminalManager.ts

@@ -10,6 +10,9 @@ export class TerminalManager implements ITerminalManager {
     public get onDidCloseTerminal(): Event<Terminal> {
         return window.onDidCloseTerminal;
     }
+    public get onDidOpenTerminal(): Event<Terminal> {
+        return window.onDidOpenTerminal;
+    }
     public createTerminal(options: TerminalOptions): Terminal {
         return window.createTerminal(options);
     }

src/client/common/application/types.ts

@@ -522,6 +522,11 @@ export interface ITerminalManager {
      * An [event](#Event) which fires when a terminal is disposed.
      */
     readonly onDidCloseTerminal: Event<Terminal>;
+    /**
+     * An [event](#Event) which fires when a terminal has been created, either through the
+     * [createTerminal](#window.createTerminal) API or commands.
+     */
+    readonly onDidOpenTerminal: Event<Terminal>;
     /**
      * Creates a [Terminal](#Terminal). The cwd of the terminal will be the workspace directory
      * if it exists, regardless of whether an explicit customStartPath setting exists.

src/client/common/terminal/factory.ts

@@ -12,7 +12,7 @@ import { ITerminalService, ITerminalServiceFactory } from './types';
 export class TerminalServiceFactory implements ITerminalServiceFactory {
     private terminalServices: Map<string, ITerminalService>;
 
-    constructor( @inject(IServiceContainer) private serviceContainer: IServiceContainer) {
+    constructor(@inject(IServiceContainer) private serviceContainer: IServiceContainer) {
 
         this.terminalServices = new Map<string, ITerminalService>();
     }

src/client/common/terminal/helper.ts

@@ -3,6 +3,7 @@
 
 import { inject, injectable } from 'inversify';
 import { Terminal, Uri } from 'vscode';
+import { sleep } from '../../../utils/async';
 import { ICondaService } from '../../interpreter/contracts';
 import { IServiceContainer } from '../../ioc/types';
 import { ITerminalManager, IWorkspaceService } from '../application/types';
@@ -29,9 +30,11 @@ const IS_TCSHELL = /(tcsh$)/i;
 @injectable()
 export class TerminalHelper implements ITerminalHelper {
     private readonly detectableShells: Map<TerminalShellType, RegExp>;
+    private readonly activatedTerminals: Set<Terminal>;
     constructor(@inject(IServiceContainer) private serviceContainer: IServiceContainer) {
 
         this.detectableShells = new Map<TerminalShellType, RegExp>();
+        this.activatedTerminals = new Set<Terminal>();
         this.detectableShells.set(TerminalShellType.powershell, IS_POWERSHELL);
         this.detectableShells.set(TerminalShellType.gitbash, IS_GITBASH);
         this.detectableShells.set(TerminalShellType.bash, IS_BASH);
@@ -108,4 +111,26 @@ export class TerminalHelper implements ITerminalHelper {
             }
         }
     }
+
+    public async activateEnvironmentInTerminal(terminal: Terminal, preserveFocus: boolean = true, resource?: Uri) {
+        if (this.activatedTerminals.has(terminal)) {
+            return;
+        }
+        this.activatedTerminals.add(terminal);
+        const shellPath = this.getTerminalShellPath();
+        const terminalShellType = !shellPath || shellPath.length === 0 ? TerminalShellType.other : this.identifyTerminalShell(shellPath);
+
+        const activationCommamnds = await this.getEnvironmentActivationCommands(terminalShellType, resource);
+        if (activationCommamnds) {
+            for (const command of activationCommamnds!) {
+                terminal.show(preserveFocus);
+                terminal.sendText(command);
+
+                // Give the command some time to complete.
+                // Its been observed that sending commands too early will strip some text off.
+                const delay = (terminalShellType === TerminalShellType.powershell || TerminalShellType.powershellCore) ? 1000 : 500;
+                await sleep(delay);
+            }
+        }
+    }
 }

src/client/common/terminal/service.ts

@@ -3,7 +3,6 @@
 
 import { inject, injectable } from 'inversify';
 import { Disposable, Event, EventEmitter, Terminal, Uri } from 'vscode';
-import { sleep } from '../../../utils/async';
 import '../../common/extensions';
 import { IInterpreterService } from '../../interpreter/contracts';
 import { IServiceContainer } from '../../ioc/types';
@@ -64,18 +63,7 @@ export class TerminalService implements ITerminalService, Disposable {
         // Sometimes the terminal takes some time to start up before it can start accepting input.
         await new Promise(resolve => setTimeout(resolve, 100));
 
-        const activationCommamnds = await this.terminalHelper.getEnvironmentActivationCommands(this.terminalShellType, this.resource);
-        if (activationCommamnds) {
-            for (const command of activationCommamnds!) {
-                this.terminal!.show(preserveFocus);
-                this.terminal!.sendText(command);
-
-                // Give the command some time to complete.
-                // Its been observed that sending commands too early will strip some text off.
-                const delay = (this.terminalShellType === TerminalShellType.powershell || TerminalShellType.powershellCore) ? 1000 : 500;
-                await sleep(delay);
-            }
-        }
+        await this.terminalHelper.activateEnvironmentInTerminal(this.terminal!, preserveFocus, this.resource);
 
         this.terminal!.show(preserveFocus);
 

src/client/common/terminal/types.ts

@@ -49,6 +49,7 @@ export interface ITerminalHelper {
     getTerminalShellPath(): string;
     buildCommandForTerminal(terminalShellType: TerminalShellType, command: string, args: string[]): string;
     getEnvironmentActivationCommands(terminalShellType: TerminalShellType, resource?: Uri): Promise<string[] | undefined>;
+    activateEnvironmentInTerminal(terminal: Terminal, preserveFocus?: boolean, resource?: Uri): Promise<void>;
 }
 
 export const ITerminalActivationCommandProvider = Symbol('ITerminalActivationCommandProvider');

src/client/extension.ts

@@ -58,7 +58,7 @@ import * as sortImports from './sortImports';
 import { sendTelemetryEvent } from './telemetry';
 import { EDITOR_LOAD } from './telemetry/constants';
 import { registerTypes as commonRegisterTerminalTypes } from './terminals/serviceRegistry';
-import { ICodeExecutionManager } from './terminals/types';
+import { ICodeExecutionManager, ITerminalAutoActivation } from './terminals/types';
 import { BlockFormatProviders } from './typeFormatters/blockFormatProvider';
 import { OnEnterFormatter } from './typeFormatters/onEnterFormatter';
 import { TEST_OUTPUT_CHANNEL } from './unittests/common/constants';
@@ -82,6 +82,7 @@ export async function activate(context: ExtensionContext) {
     interpreterManager.initialize();
     await interpreterManager.autoSetInterpreter();
 
+    serviceManager.get<ITerminalAutoActivation>(ITerminalAutoActivation).initilialize();
     const configuration = serviceManager.get<IConfigurationService>(IConfigurationService);
     const pythonSettings = configuration.getSettings();
 

src/client/terminals/activation.ts

@@ -0,0 +1,29 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+import { inject, injectable } from 'inversify';
+import { Disposable, Terminal } from 'vscode';
+import { ITerminalManager } from '../common/application/types';
+import { ITerminalHelper } from '../common/terminal/types';
+import { IDisposableRegistry } from '../common/types';
+import { IServiceContainer } from '../ioc/types';
+import { ITerminalAutoActivation } from './types';
+
+@injectable()
+export class TerminalAutoActivation implements ITerminalAutoActivation {
+    private readonly helper: ITerminalHelper;
+    constructor(@inject(IServiceContainer) private container: IServiceContainer) {
+        this.helper = container.get<ITerminalHelper>(ITerminalHelper);
+    }
+    public initilialize() {
+        const manager = this.container.get<ITerminalManager>(ITerminalManager);
+        const disposables = this.container.get<Disposable[]>(IDisposableRegistry);
+        const disposable = manager.onDidOpenTerminal(this.activateTerminal, this);
+        disposables.push(disposable);
+    }
+    public activateTerminal(terminal: Terminal): Promise<void> {
+        return this.helper.activateEnvironmentInTerminal(terminal);
+    }
+}

src/client/terminals/serviceRegistry.ts

@@ -2,17 +2,19 @@
 // Licensed under the MIT License.
 
 import { IServiceManager } from '../ioc/types';
+import { TerminalAutoActivation } from './activation';
 import { CodeExecutionManager } from './codeExecution/codeExecutionManager';
 import { DjangoShellCodeExecutionProvider } from './codeExecution/djangoShellCodeExecution';
 import { CodeExecutionHelper } from './codeExecution/helper';
 import { ReplProvider } from './codeExecution/repl';
 import { TerminalCodeExecutionProvider } from './codeExecution/terminalCodeExecution';
-import { ICodeExecutionHelper, ICodeExecutionManager, ICodeExecutionService } from './types';
+import { ICodeExecutionHelper, ICodeExecutionManager, ICodeExecutionService, ITerminalAutoActivation } from './types';
 
 export function registerTypes(serviceManager: IServiceManager) {
     serviceManager.addSingleton<ICodeExecutionHelper>(ICodeExecutionHelper, CodeExecutionHelper);
     serviceManager.addSingleton<ICodeExecutionManager>(ICodeExecutionManager, CodeExecutionManager);
     serviceManager.addSingleton<ICodeExecutionService>(ICodeExecutionService, DjangoShellCodeExecutionProvider, 'djangoShell');
     serviceManager.addSingleton<ICodeExecutionService>(ICodeExecutionService, TerminalCodeExecutionProvider, 'standard');
     serviceManager.addSingleton<ICodeExecutionService>(ICodeExecutionService, ReplProvider, 'repl');
+    serviceManager.addSingleton<ITerminalAutoActivation>(ITerminalAutoActivation, TerminalAutoActivation);
 }

src/client/terminals/types.ts

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-import { TextEditor, Uri } from 'vscode';
+import { Terminal, TextEditor, Uri } from 'vscode';
 
 export const ICodeExecutionService = Symbol('ICodeExecutionService');
 
@@ -25,3 +25,9 @@ export const ICodeExecutionManager = Symbol('ICodeExecutionManager');
 export interface ICodeExecutionManager {
     registerCommands(): void;
 }
+
+export const ITerminalAutoActivation = Symbol('ITerminalAutoActivation');
+export interface ITerminalAutoActivation {
+    initilialize(): void;
+    activateTerminal(terminal: Terminal): Promise<void>;
+}