Switch over to executeCommand from sendText

package.json

@@ -45,7 +45,7 @@
         "theme": "dark"
     },
     "engines": {
-        "vscode": "^1.91.0"
+        "vscode": "^1.93.0"
     },
     "enableTelemetry": false,
     "keywords": [
@@ -1570,7 +1570,7 @@
         "@types/sinon": "^17.0.3",
         "@types/stack-trace": "0.0.29",
         "@types/tmp": "^0.0.33",
-        "@types/vscode": "^1.81.0",
+        "@types/vscode": "^1.93.0",
         "@types/which": "^2.0.1",
         "@types/winreg": "^1.2.30",
         "@types/xml2js": "^0.4.2",

src/client/common/application/terminalManager.ts

@@ -2,7 +2,16 @@
 // Licensed under the MIT License.
 
 import { injectable } from 'inversify';
-import { Event, EventEmitter, Terminal, TerminalOptions, window } from 'vscode';
+import {
+    Disposable,
+    Event,
+    EventEmitter,
+    Terminal,
+    TerminalOptions,
+    TerminalShellExecutionEndEvent,
+    TerminalShellIntegrationChangeEvent,
+    window,
+} from 'vscode';
 import { traceLog } from '../../logging';
 import { ITerminalManager } from './types';
 
@@ -23,6 +32,12 @@ export class TerminalManager implements ITerminalManager {
     public createTerminal(options: TerminalOptions): Terminal {
         return monkeyPatchTerminal(window.createTerminal(options));
     }
+    public onDidChangeTerminalShellIntegration(handler: (e: TerminalShellIntegrationChangeEvent) => void): Disposable {
+        return window.onDidChangeTerminalShellIntegration(handler);
+    }
+    public onDidEndTerminalShellExecution(handler: (e: TerminalShellExecutionEndEvent) => void): Disposable {
+        return window.onDidEndTerminalShellExecution(handler);
+    }
 }
 
 /**

src/client/common/application/types.ts

@@ -40,6 +40,8 @@ import {
     StatusBarItem,
     Terminal,
     TerminalOptions,
+    TerminalShellExecutionEndEvent,
+    TerminalShellIntegrationChangeEvent,
     TextDocument,
     TextDocumentChangeEvent,
     TextDocumentShowOptions,
@@ -936,6 +938,10 @@ export interface ITerminalManager {
      * @return A new Terminal.
      */
     createTerminal(options: TerminalOptions): Terminal;
+
+    onDidChangeTerminalShellIntegration(handler: (e: TerminalShellIntegrationChangeEvent) => void): Disposable;
+
+    onDidEndTerminalShellExecution(handler: (e: TerminalShellExecutionEndEvent) => void): Disposable;
 }
 
 export const IDebugService = Symbol('IDebugManager');

src/client/common/terminal/service.ts

@@ -20,6 +20,7 @@ import {
     ITerminalService,
     TerminalCreationOptions,
     TerminalShellType,
+    ITerminalExecutedCommand,
 } from './types';
 
 @injectable()
@@ -32,6 +33,7 @@ export class TerminalService implements ITerminalService, Disposable {
     private terminalActivator: ITerminalActivator;
     private terminalAutoActivator: ITerminalAutoActivation;
     private readonly envVarScript = path.join(EXTENSION_ROOT_DIR, 'python_files', 'pythonrc.py');
+    private readonly executeCommandListeners: Set<Disposable> = new Set();
     public get onDidCloseTerminal(): Event<void> {
         return this.terminalClosed.event.bind(this.terminalClosed);
     }
@@ -48,8 +50,12 @@ export class TerminalService implements ITerminalService, Disposable {
         this.terminalActivator = this.serviceContainer.get<ITerminalActivator>(ITerminalActivator);
     }
     public dispose() {
-        if (this.terminal) {
-            this.terminal.dispose();
+        this.terminal?.dispose();
+
+        if (this.executeCommandListeners && this.executeCommandListeners.size > 0) {
+            this.executeCommandListeners.forEach((d) => {
+                d?.dispose();
+            });
         }
     }
     public async sendCommand(command: string, args: string[], _?: CancellationToken): Promise<void> {
@@ -59,21 +65,67 @@ export class TerminalService implements ITerminalService, Disposable {
             this.terminal!.show(true);
         }
 
-        this.terminal!.sendText(text, true);
+        await this.executeCommand(text);
     }
+    /** @deprecated */
     public async sendText(text: string): Promise<void> {
         await this.ensureTerminal();
         if (!this.options?.hideFromUser) {
             this.terminal!.show(true);
         }
         this.terminal!.sendText(text);
     }
+    public async executeCommand(commandLine: string): Promise<ITerminalExecutedCommand | undefined> {
+        const terminal = this.terminal!;
+        if (!this.options?.hideFromUser) {
+            terminal.show(true);
+        }
+
+        // If terminal was just launched, wait some time for shell integration to onDidChangeShellIntegration.
+        if (!terminal.shellIntegration) {
+            const promise = new Promise<boolean>((resolve) => {
+                const shellIntegrationChangeEventListener = this.terminalManager.onDidChangeTerminalShellIntegration(
+                    () => {
+                        this.executeCommandListeners.delete(shellIntegrationChangeEventListener);
+                        resolve(true);
+                    },
+                );
+                const TIMEOUT_DURATION = 3000;
+                setTimeout(() => {
+                    this.executeCommandListeners.add(shellIntegrationChangeEventListener);
+                    resolve(true);
+                }, TIMEOUT_DURATION);
+            });
+            await promise;
+        }
+
+        if (terminal.shellIntegration) {
+            const execution = terminal.shellIntegration.executeCommand(commandLine);
+            return await new Promise((resolve) => {
+                const listener = this.terminalManager.onDidEndTerminalShellExecution((e) => {
+                    if (e.execution === execution) {
+                        this.executeCommandListeners.delete(listener);
+                        resolve({ execution, exitCode: e.exitCode });
+                    }
+                });
+                if (listener) {
+                    this.executeCommandListeners.add(listener);
+                }
+            });
+        } else {
+            terminal.sendText(commandLine);
+        }
+
+        return undefined;
+    }
+
     public async show(preserveFocus: boolean = true): Promise<void> {
         await this.ensureTerminal(preserveFocus);
         if (!this.options?.hideFromUser) {
             this.terminal!.show(preserveFocus);
         }
     }
+    // TODO: Debt switch to Promise<Terminal> ---> breaks 20 tests
     public async ensureTerminal(preserveFocus: boolean = true): Promise<void> {
         if (this.terminal) {
             return;
@@ -89,18 +141,19 @@ 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));
 
-        await this.terminalActivator.activateEnvironmentInTerminal(this.terminal!, {
+        await this.terminalActivator.activateEnvironmentInTerminal(this.terminal, {
             resource: this.options?.resource,
             preserveFocus,
             interpreter: this.options?.interpreter,
             hideFromUser: this.options?.hideFromUser,
         });
 
         if (!this.options?.hideFromUser) {
-            this.terminal!.show(preserveFocus);
+            this.terminal.show(preserveFocus);
         }
 
         this.sendTelemetry().ignoreErrors();
+        return;
     }
     private terminalCloseHandler(terminal: Terminal) {
         if (terminal === this.terminal) {

src/client/common/terminal/syncTerminalService.ts

@@ -14,7 +14,7 @@ import * as internalScripts from '../process/internal/scripts';
 import { createDeferred, Deferred } from '../utils/async';
 import { noop } from '../utils/misc';
 import { TerminalService } from './service';
-import { ITerminalService } from './types';
+import { ITerminalService, ITerminalExecutedCommand } from './types';
 
 enum State {
     notStarted = 0,
@@ -146,9 +146,13 @@ export class SynchronousTerminalService implements ITerminalService, Disposable
             lockFile.dispose();
         }
     }
+    /** @deprecated */
     public sendText(text: string): Promise<void> {
         return this.terminalService.sendText(text);
     }
+    public executeCommand(commandLine: string): Promise<ITerminalExecutedCommand | undefined> {
+        return this.terminalService.executeCommand(commandLine);
+    }
     public show(preserveFocus?: boolean | undefined): Promise<void> {
         return this.terminalService.show(preserveFocus);
     }

src/client/common/terminal/types.ts

@@ -3,7 +3,7 @@
 
 'use strict';
 
-import { CancellationToken, Event, Terminal, Uri } from 'vscode';
+import { CancellationToken, Event, Terminal, Uri, TerminalShellExecution } from 'vscode';
 import { PythonEnvironment } from '../../pythonEnvironments/info';
 import { IEventNamePropertyMapping } from '../../telemetry/index';
 import { IDisposable, Resource } from '../types';
@@ -52,10 +52,17 @@ export interface ITerminalService extends IDisposable {
         cancel?: CancellationToken,
         swallowExceptions?: boolean,
     ): Promise<void>;
+    /** @deprecated */
     sendText(text: string): Promise<void>;
+    executeCommand(commandLine: string): Promise<ITerminalExecutedCommand | undefined>;
     show(preserveFocus?: boolean): Promise<void>;
 }
 
+export interface ITerminalExecutedCommand {
+    execution: TerminalShellExecution;
+    exitCode: number | undefined;
+}
+
 export const ITerminalServiceFactory = Symbol('ITerminalServiceFactory');
 
 export type TerminalCreationOptions = {

src/client/terminals/codeExecution/terminalCodeExecution.ts

@@ -59,7 +59,7 @@ export class TerminalCodeExecutionProvider implements ICodeExecutionService {
                 this.configurationService.updateSetting('REPL.enableREPLSmartSend', false, resource);
             }
         } else {
-            await this.getTerminalService(resource).sendText(code);
+            await this.getTerminalService(resource).executeCommand(code);
         }
     }
 

src/test/common/terminals/service.unit.test.ts

@@ -4,7 +4,15 @@
 import { expect } from 'chai';
 import * as path from 'path';
 import * as TypeMoq from 'typemoq';
-import { Disposable, Terminal as VSCodeTerminal, WorkspaceConfiguration } from 'vscode';
+import {
+    Disposable,
+    EventEmitter,
+    TerminalShellExecution,
+    TerminalShellExecutionEndEvent,
+    TerminalShellIntegration,
+    Terminal as VSCodeTerminal,
+    WorkspaceConfiguration,
+} from 'vscode';
 import { ITerminalManager, IWorkspaceService } from '../../../client/common/application/types';
 import { EXTENSION_ROOT_DIR } from '../../../client/common/constants';
 import { IPlatformService } from '../../../client/common/platform/types';
@@ -26,9 +34,44 @@ suite('Terminal Service', () => {
     let disposables: Disposable[] = [];
     let mockServiceContainer: TypeMoq.IMock<IServiceContainer>;
     let terminalAutoActivator: TypeMoq.IMock<ITerminalAutoActivation>;
+    let terminalShellIntegration: TypeMoq.IMock<TerminalShellIntegration>;
+    let onDidEndTerminalShellExecutionEmitter: EventEmitter<TerminalShellExecutionEndEvent>;
+    let event: TerminalShellExecutionEndEvent;
+
     setup(() => {
         terminal = TypeMoq.Mock.ofType<VSCodeTerminal>();
+        terminalShellIntegration = TypeMoq.Mock.ofType<TerminalShellIntegration>();
+        terminal.setup((t) => t.shellIntegration).returns(() => terminalShellIntegration.object);
+
+        onDidEndTerminalShellExecutionEmitter = new EventEmitter<TerminalShellExecutionEndEvent>();
         terminalManager = TypeMoq.Mock.ofType<ITerminalManager>();
+        const execution: TerminalShellExecution = {
+            commandLine: {
+                value: 'dummy text',
+                isTrusted: true,
+                confidence: 2,
+            },
+            cwd: undefined,
+            read: function (): AsyncIterable<string> {
+                throw new Error('Function not implemented.');
+            },
+        };
+
+        event = {
+            execution,
+            exitCode: 0,
+            terminal: terminal.object,
+            shellIntegration: terminalShellIntegration.object,
+        };
+
+        terminalShellIntegration.setup((t) => t.executeCommand(TypeMoq.It.isAny())).returns(() => execution);
+
+        terminalManager
+            .setup((t) => t.onDidEndTerminalShellExecution)
+            .returns(() => {
+                setTimeout(() => onDidEndTerminalShellExecutionEmitter.fire(event), 100);
+                return onDidEndTerminalShellExecutionEmitter.event;
+            });
         platformService = TypeMoq.Mock.ofType<IPlatformService>();
         workspaceService = TypeMoq.Mock.ofType<IWorkspaceService>();
         terminalHelper = TypeMoq.Mock.ofType<ITerminalHelper>();
@@ -37,6 +80,7 @@ suite('Terminal Service', () => {
         disposables = [];
 
         mockServiceContainer = TypeMoq.Mock.ofType<IServiceContainer>();
+
         mockServiceContainer.setup((c) => c.get(ITerminalManager)).returns(() => terminalManager.object);
         mockServiceContainer.setup((c) => c.get(ITerminalHelper)).returns(() => terminalHelper.object);
         mockServiceContainer.setup((c) => c.get(IPlatformService)).returns(() => platformService.object);
@@ -75,10 +119,16 @@ suite('Terminal Service', () => {
             .setup((h) => h.buildCommandForTerminal(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny()))
             .returns(() => 'dummy text');
 
+        terminalManager
+            .setup((t) => t.onDidEndTerminalShellExecution)
+            .returns(() => {
+                setTimeout(() => onDidEndTerminalShellExecutionEmitter.fire(event), 100);
+                return onDidEndTerminalShellExecutionEmitter.event;
+            });
         // Sending a command will cause the terminal to be created
         await service.sendCommand('', []);
 
-        terminal.verify((t) => t.show(TypeMoq.It.isValue(true)), TypeMoq.Times.exactly(2));
+        terminal.verify((t) => t.show(TypeMoq.It.isValue(true)), TypeMoq.Times.atLeastOnce());
         service.dispose();
         terminal.verify((t) => t.dispose(), TypeMoq.Times.exactly(1));
     });
@@ -99,10 +149,10 @@ suite('Terminal Service', () => {
 
         await service.sendCommand(commandToSend, args);
 
-        terminal.verify((t) => t.show(TypeMoq.It.isValue(true)), TypeMoq.Times.exactly(2));
+        terminal.verify((t) => t.show(TypeMoq.It.isValue(true)), TypeMoq.Times.atLeastOnce());
         terminal.verify(
             (t) => t.sendText(TypeMoq.It.isValue(commandToExpect), TypeMoq.It.isValue(true)),
-            TypeMoq.Times.exactly(1),
+            TypeMoq.Times.never(),
         );
     });