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/terminal/service.ts

@@ -3,7 +3,7 @@
 
 import { inject, injectable } from 'inversify';
 import * as path from 'path';
-import { CancellationToken, Disposable, Event, EventEmitter, Terminal } from 'vscode';
+import { CancellationToken, Disposable, Event, EventEmitter, Terminal, window } from 'vscode';
 import '../../common/extensions';
 import { IInterpreterService } from '../../interpreter/contracts';
 import { IServiceContainer } from '../../ioc/types';
@@ -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,10 @@ export class TerminalService implements ITerminalService, Disposable {
         this.terminalActivator = this.serviceContainer.get<ITerminalActivator>(ITerminalActivator);
     }
     public dispose() {
-        if (this.terminal) {
-            this.terminal.dispose();
+        this.terminal?.dispose();
+
+        for (const d of this.executeCommandListeners) {
+            d.dispose();
         }
     }
     public async sendCommand(command: string, args: string[], _?: CancellationToken): Promise<void> {
@@ -59,24 +63,64 @@ 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 = await this.ensureTerminal();
+        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 = window.onDidChangeTerminalShellIntegration(() => {
+                    this.executeCommandListeners.delete(shellIntegrationChangeEventListener);
+                    resolve(true);
+                });
+                setTimeout(() => {
+                    this.executeCommandListeners.add(shellIntegrationChangeEventListener);
+                    resolve(true);
+                }, 3000);
+            });
+            await promise;
+        }
+
+        if (terminal.shellIntegration) {
+            const execution = terminal.shellIntegration.executeCommand(commandLine);
+            return await new Promise((resolve) => {
+                const listener = window.onDidEndTerminalShellExecution((e) => {
+                    if (e.execution === execution) {
+                        this.executeCommandListeners.delete(listener);
+                        resolve({ execution, exitCode: e.exitCode });
+                    }
+                });
+                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);
         }
     }
-    public async ensureTerminal(preserveFocus: boolean = true): Promise<void> {
+    public async ensureTerminal(preserveFocus: boolean = true): Promise<Terminal> {
         if (this.terminal) {
-            return;
+            return this.terminal;
         }
         this.terminalShellType = this.terminalHelper.identifyTerminalShell(this.terminal);
         this.terminal = this.terminalManager.createTerminal({
@@ -97,10 +141,11 @@ export class TerminalService implements ITerminalService, Disposable {
         });
 
         if (!this.options?.hideFromUser) {
-            this.terminal!.show(preserveFocus);
+            this.terminal.show(preserveFocus);
         }
 
         this.sendTelemetry().ignoreErrors();
+        return this.terminal;
     }
     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/interpreters/activation/terminalEnvVarCollectionService.unit.test.ts

@@ -134,7 +134,6 @@ suite('Terminal Environment Variable Collection Service', () => {
 
     test('When not in experiment, do not apply activated variables to the collection and clear it instead', async () => {
         reset(experimentService);
-        when(context.environmentVariableCollection).thenReturn(instance(collection));
         when(experimentService.inExperimentSync(TerminalEnvVarActivation.experiment)).thenReturn(false);
         const applyCollectionStub = sinon.stub(terminalEnvVarCollectionService, '_applyCollection');
         applyCollectionStub.resolves();

src/test/mocks/vsc/index.ts

@@ -369,6 +369,8 @@ export class CodeActionKind {
 
     public static readonly SourceFixAll: CodeActionKind = new CodeActionKind('source.fix.all');
 
+    public static readonly Notebook: CodeActionKind = new CodeActionKind('notebook');
+
     private constructor(private _value: string) {}
 
     public append(parts: string): CodeActionKind {

types/vscode.proposed.envCollectionWorkspace.d.ts

@@ -27,11 +27,4 @@ declare module 'vscode' {
          */
         getScoped(scope: EnvironmentVariableScope): EnvironmentVariableCollection;
     }
-
-    export type EnvironmentVariableScope = {
-        /**
-         * Any specific workspace folder to get collection for. If unspecified, collection applicable to all workspace folders is returned.
-         */
-        workspaceFolder?: WorkspaceFolder;
-    };
 }