Automatically relaunch terminals when pty host is restarted

Fixes #117548

src/vs/platform/terminal/common/terminal.ts

@@ -395,15 +395,15 @@ export interface ITerminalDimensions {
 	/**
 	 * The columns of the terminal.
 	 */
-	readonly cols: number;
+	cols: number;
 
 	/**
 	 * The rows of the terminal.
 	 */
-	readonly rows: number;
+	rows: number;
 }
 
-export interface ITerminalDimensionsOverride extends ITerminalDimensions {
+export interface ITerminalDimensionsOverride extends Readonly<ITerminalDimensions> {
 	/**
 	 * indicate that xterm must receive these exact dimensions, even if they overflow the ui!
 	 */

src/vs/platform/terminal/node/ptyHostService.ts

@@ -95,8 +95,10 @@ export class PtyHostService extends Disposable implements IPtyService {
 		);
 		this._onPtyHostStart.fire();
 
+		// Setup heartbeat service and trigger a heartbeat immediately to reset the timeouts
 		const heartbeatService = ProxyChannel.toService<IHeartbeatService>(client.getChannel(TerminalIpcChannels.Heartbeat));
 		heartbeatService.onBeat(() => this._handleHeartbeat());
+		this._handleHeartbeat();
 
 		// Handle exit
 		this._register(client.onDidProcessExit(e => {

src/vs/workbench/contrib/terminal/browser/remoteTerminalService.ts

@@ -78,7 +78,7 @@ export class RemoteTerminalService extends Disposable implements IRemoteTerminal
 			// Attach pty host listeners
 			if (channel.onPtyHostExit) {
 				this._register(channel.onPtyHostExit(() => {
-					notificationService.error(`The terminal's pty host process exited, the connection to all terminal processes was lost`);
+					this._logService.error(`The terminal's pty host process exited, the connection to all terminal processes was lost`);
 				}));
 			}
 			let unresponsiveNotification: INotificationHandle | undefined;

src/vs/workbench/contrib/terminal/browser/terminalInstance.ts

@@ -49,6 +49,7 @@ import { IPreferencesService } from 'vs/workbench/services/preferences/common/pr
 import { IEnvironmentVariableInfo } from 'vs/workbench/contrib/terminal/common/environmentVariable';
 import { IProcessDataEvent, IShellLaunchConfig, ITerminalDimensionsOverride, ITerminalLaunchError, TerminalShellType } from 'vs/platform/terminal/common/terminal';
 import { IProductService } from 'vs/platform/product/common/productService';
+import { formatMessageForTerminal } from 'vs/workbench/contrib/terminal/common/terminalStrings';
 
 // How long in milliseconds should an average frame take to render for a notification to appear
 // which suggests the fallback DOM-based renderer
@@ -1065,10 +1066,7 @@ export class TerminalInstance extends Disposable implements ITerminalInstance {
 					xterm.writeln(exitCodeMessage);
 				}
 				if (typeof this._shellLaunchConfig.waitOnExit === 'string') {
-					let message = this._shellLaunchConfig.waitOnExit;
-					// Bold the message and add an extra new line to make it stand out from the rest of the output
-					message = `\r\n\x1b[1m${message}\x1b[0m`;
-					xterm.writeln(message);
+					xterm.write(formatMessageForTerminal(this._shellLaunchConfig.waitOnExit));
 				}
 				// Disable all input if the terminal is exiting and listen for next keypress
 				xterm.setOption('disableStdin', true);

src/vs/workbench/contrib/terminal/browser/terminalProcessManager.ts

@@ -27,8 +27,10 @@ import { EnvironmentVariableInfoChangesActive, EnvironmentVariableInfoStale } fr
 import { IPathService } from 'vs/workbench/services/path/common/pathService';
 import { URI } from 'vs/base/common/uri';
 import { IEnvironmentVariableInfo, IEnvironmentVariableService, IMergedEnvironmentVariableCollection } from 'vs/workbench/contrib/terminal/common/environmentVariable';
-import { IProcessDataEvent, IShellLaunchConfig, ITerminalChildProcess, ITerminalDimensionsOverride, ITerminalEnvironment, ITerminalLaunchError, FlowControlConstants, TerminalShellType, ILocalTerminalService, IOffProcessTerminalService } from 'vs/platform/terminal/common/terminal';
+import { IProcessDataEvent, IShellLaunchConfig, ITerminalChildProcess, ITerminalDimensionsOverride, ITerminalEnvironment, ITerminalLaunchError, FlowControlConstants, TerminalShellType, ILocalTerminalService, IOffProcessTerminalService, ITerminalDimensions } from 'vs/platform/terminal/common/terminal';
 import { TerminalRecorder } from 'vs/platform/terminal/common/terminalRecorder';
+import { localize } from 'vs/nls';
+import { formatMessageForTerminal } from 'vs/workbench/contrib/terminal/common/terminalStrings';
 
 /** The amount of time to consider terminal errors to be related to the launch */
 const LAUNCHING_DURATION = 500;
@@ -74,7 +76,10 @@ export class TerminalProcessManager extends Disposable implements ITerminalProce
 	private _ptyResponsiveListener: IDisposable | undefined;
 	private _ptyListenersAttached: boolean = false;
 	private _dataFilter: SeamlessRelaunchDataFilter;
-	private _isFeatureTerminal: boolean = false;
+
+	private _shellLaunchConfig?: IShellLaunchConfig;
+	private _dimensions: ITerminalDimensions = { cols: 0, rows: 0 };
+	private _isScreenReaderModeEnabled: boolean = false;
 
 	private readonly _onPtyDisconnect = this._register(new Emitter<void>());
 	public get onPtyDisconnect(): Event<void> { return this._onPtyDisconnect.event; }
@@ -178,7 +183,11 @@ export class TerminalProcessManager extends Disposable implements ITerminalProce
 		isScreenReaderModeEnabled: boolean,
 		reset: boolean = true
 	): Promise<ITerminalLaunchError | undefined> {
-		this._isFeatureTerminal = !!shellLaunchConfig.isFeatureTerminal;
+		this._shellLaunchConfig = shellLaunchConfig;
+		this._dimensions.cols = cols;
+		this._dimensions.rows = rows;
+		this._isScreenReaderModeEnabled = isScreenReaderModeEnabled;
+
 		if (shellLaunchConfig.isExtensionCustomPtyTerminal) {
 			this._processType = ProcessType.ExtensionTerminal;
 			this._process = this._instantiationService.createInstance(TerminalProcessExtHostProxy, this._instanceId, shellLaunchConfig, cols, rows);
@@ -300,6 +309,13 @@ export class TerminalProcessManager extends Disposable implements ITerminalProce
 	public async relaunch(shellLaunchConfig: IShellLaunchConfig, cols: number, rows: number, isScreenReaderModeEnabled: boolean, reset: boolean): Promise<ITerminalLaunchError | undefined> {
 		this.ptyProcessReady = this._createPtyProcessReadyPromise();
 		this._logService.trace(`Relaunching terminal instance ${this._instanceId}`);
+
+		// Fire reconnect if needed to ensure the terminal is usable again
+		if (this.isDisconnected) {
+			this.isDisconnected = false;
+			this._onPtyReconnect.fire();
+		}
+
 		return this.createProcess(shellLaunchConfig, cols, rows, isScreenReaderModeEnabled, reset);
 	}
 
@@ -398,20 +414,29 @@ export class TerminalProcessManager extends Disposable implements ITerminalProce
 
 		// When the pty host restarts, reconnect is no longer possible so dispose the responsive
 		// listener
-		this._register(offProcessTerminalService.onPtyHostRestart(() => {
+		this._register(offProcessTerminalService.onPtyHostRestart(async () => {
 			// When the pty host restarts, reconnect is no longer possible
 			if (!this.isDisconnected) {
 				this.isDisconnected = true;
 				this._onPtyDisconnect.fire();
 			}
 			this._ptyResponsiveListener?.dispose();
 			this._ptyResponsiveListener = undefined;
-			// Indicate the process is exited (and gone forever) only for feature terminals so they
-			// can react to the exit, this is particularly important for tasks so that it knows that
-			// the process is not still active. Note that this is not done for regular terminals
-			// because otherwise the terminal instance would be disposed
-			if (this._isFeatureTerminal) {
-				this._onExit(undefined);
+			if (this._shellLaunchConfig) {
+				if (this._shellLaunchConfig.isFeatureTerminal) {
+					// Indicate the process is exited (and gone forever) only for feature terminals
+					// so they can react to the exit, this is particularly important for tasks so
+					// that it knows that the process is not still active. Note that this is not
+					// done for regular terminals because otherwise the terminal instance would be
+					// disposed.
+					this._onExit(undefined);
+				} else {
+					// For normal terminals write a message indicating what happened and relaunch
+					// using the previous shellLaunchConfig
+					let message = localize('ptyHostRelaunch', "Restarting the terminal because the connection to the shell process was lost...");
+					this._onProcessData.fire({ data: formatMessageForTerminal(message), sync: false });
+					await this.relaunch(this._shellLaunchConfig, this._dimensions.cols, this._dimensions.rows, this._isScreenReaderModeEnabled, false);
+				}
 			}
 		}));
 	}
@@ -442,6 +467,8 @@ export class TerminalProcessManager extends Disposable implements ITerminalProce
 				throw (error);
 			}
 		}
+		this._dimensions.cols = cols;
+		this._dimensions.rows = rows;
 	}
 
 	public async write(data: string): Promise<void> {

src/vs/workbench/contrib/terminal/common/terminalStrings.ts

@@ -0,0 +1,12 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/**
+ * Formats a message from the product to be written to the terminal.
+ */
+export function formatMessageForTerminal(message: string): string {
+	// Wrap in bold and ensure it's on a new line
+	return `\r\n\x1b[1m${message}\x1b[0m\n\r`;
+}

src/vs/workbench/contrib/terminal/electron-sandbox/localPty.ts

@@ -39,12 +39,6 @@ export class LocalPty extends Disposable implements ITerminalChildProcess {
 		@ILocalPtyService private readonly _localPtyService: ILocalPtyService
 	) {
 		super();
-
-		if (this._localPtyService.onPtyHostExit) {
-			this._localPtyService.onPtyHostExit(() => {
-				this._onProcessExit.fire(undefined);
-			});
-		}
 	}
 
 	start(): Promise<ITerminalLaunchError | undefined> {

src/vs/workbench/contrib/terminal/electron-sandbox/localTerminalService.ts

@@ -59,7 +59,7 @@ export class LocalTerminalService extends Disposable implements ILocalTerminalSe
 		// Attach pty host listeners
 		if (this._localPtyService.onPtyHostExit) {
 			this._register(this._localPtyService.onPtyHostExit(() => {
-				notificationService.error(`The terminal's pty host process exited, the connection to all terminal processes was lost`);
+				this._logService.error(`The terminal's pty host process exited, the connection to all terminal processes was lost`);
 			}));
 		}
 		let unresponsiveNotification: INotificationHandle | undefined;